Entity-Relationship Approach — ER '94 Business Modelling and Re-Engineering

Business Process Re-engineering (BPR) is much in vogue both as an approach to the rationalisation of Corporate Organisations and as an aid to the design of the IT system which supports the Organisation.The field of Software Process Modelling (SPM) started some 10 years ago with the objective of modelling and thence supporting the total set of software engineering activities necessary to develop and maintain software products.They both arose as a result of dissatisfaction with the current approaches to their respective domains. They share the word process but is there any other connection between them? This paper attempts to outline some possible synergies and pitfalls which might derive from a closer contact between the two disciplines.

The focus of this paper is on the modeling of application and business processes in Cooperative Information Systems. Such processes use several resources and services to achieve a common, global system goal. We integrate the proposed concepts into the framework of a formal object-oriented specification language (Troll). The goals of our approach are to provide additional modeling support for business and application processes, to explain these processes in the underlying framework and to couple tightly the modeling of global processes and the modeling of structural aspects of the system.

To build efficient information systems it is important to understand and to optimize the business processes which should be supported. INCOME/STAR is an integrated environment for the cooperative development of large, distributed information systems. INCOME/STAR supports the conceptual modelling of structural system aspects by the entity relationship model and of dynamic system aspects by high level Petri nets. This combination provides a powerful concept for the integrated modelling of business processes.The behaviour of the complex object types within business processes can be described by a new variant of Petri nets, so-called Nested Relation/Transition-Nets. In this paper we suggest a new concept for the derivation of complex structured object types to be used for business process modelling. Complex object types can be interpreted as views on a given global entity relationship scheme. We give rules how to derive such complex object types from the global scheme and represent them as object types in a semantic hierarchy model as well as in an extended ER model.

Most of todays approaches to business process engineering (also called business process management) start from an activity-centered perspective. They describe activities to be carried out within a business process and their relationships, but they usually pay little attention to the objects manipulated within processes. In this article we discuss an approach to business process management which is based on modeling data-related, activity-related, and organizational aspects of business processes. In fact, the Leu approach to business process management considers data models (describing types of objects to be manipulated in a business process and their relationships), activity models (describing activities to be carried out in a business process), and organization models (describing organizational entities involved in a business process) as separate, but equally important, facets of business processes.

This paper proposes a method with which an ER model, an important part of Enterprise-wide Conceptual Data Model, can be designed from existing information resources scattered all over the enterprise application systems. The method comprises concept extraction through data element name analysis, semantic network synthesis to express associations among the concepts, the extraction of principal concepts as possible entity types from the semantic network and attribute assignment. An evaluation of the method using data elements from NTT's customer management sector shows its effectiveness. We have implemented part of the algorithm, and it has reduced much of the work load of our ER model designers.

Information system development lacks support for the organisational modelling and analysis which should be carried out prior to or concurrent with the requirements determination stage. We propose a new approach, termed Organizational Requirements Engineering (ORE), for requirements determination, which links together organisational and information system modelling, provides for re-engineering the organisation, and contains new diagrammatic methods both for organisational as well as information system modelling, which focus on the event. The method is designed to allow users to build their own organisational models. Parts of the method are supported by software tools. In addition, the results of an action research study show the ORE approach to organisational modelling compares favourably with that of data flow diagramming.

This paper develops a framework for evaluating the quality of data models and choosing between alternative representations of requirements. For any particular set of user requirements there are many possible models, each of which has drastically different implications for database and systems design. In the absence of formally defined and agreed criteria, the choice of an appropriate representation is usually made in an ad hoc way, based on personal opinion. The evaluation framework proposed consists of four major constructs: qualities (desirable properties of a data model), metrics (ways of measuring each quality), weightings (relative importance of each quality) and strategies (ways of improving data models). Using this framework, any two data models may be compared in an objective and comprehensive manner. The evaluation framework also builds commitment to the model by involving all stakeholders in the process: end users, management, the data administrator and application developers.

The paper analyses some of the practical problems that arise when the requirements of an information system evolve, and when the database and its application programs are to be modified accordingly. It presents four important strategies to cope with this evolution, namely forward maintenance, backward maintenance, reverse engineering and anticipating design. A common, generic, framework that can support these strategies is described. It is based on a generic data structure model, on a transformational approach to database engineering, and on a design process model. The paper discusses how this framework allows formalizing these evolution strategies, and describes a generic CASE tool that supports database applications maintenance.

A flexible database system needs to support changes to its schema in order to facilitate the requirements of new applications and to support interoperability within a multidatabase system. In this paper, we present an approach to schema evolution through changes to the Entity-Relationship (ER) schema of a database. We enhance the graphical constructs used in ER diagrams, and develop EVER, an Evolutionary ER diagram for specifying the derivation relationships between schema versions, relationships among attributes, and the conditions for maintaining consistent views of programs. Algorithms are presented for mapping the EVER diagram into the underlying database and constructing database views for schema versions. Through the reconstruction of views after database reorganization, changes to an ER diagram can be made transparent to the application programs while all objects in the database remain accessible to the application programs.

In this paper we present a framework and algorithms for method evolution handling in object-oriented databases. Two levels of granularity for method evolution are described. The first level to the evolution of methods in the context of the class inheritance hierarchy, and concerns the semantics of the polymorphism. The second level relates to the behavioural evolution in which the chain of calling relationships between methods is considered. A graph based approach is used to achieve such behavioural consistency in order to prevent the problems of run-time errors, side-effects, and to detect redundant methods and unexpected behaviours.

Integrity constraints are usually modeled based on the assumption that they are valid in any database state. This approach underdetermine integrity constraints, leads to strong influence of exceptions and requires complex operational support. However, for operating databases finer granularity in integrity and operational modeling is required. This paper proposes dynamic state-oriented modeling of integrity constraints. It has several advantages over other approaches: modeling is simpler; exceptions are modeled together with states; integrity maintenance is simpler; modeling granularity is higher; incorrect operations can be corrected; generic operations have greatest consistent specializations; parallelism is supported. Further, transactions can be distinguished into state preserving transactions and state transformation transactions. This distinction supports specialized handling of special transactions.

This paper deals with modelling constraints in object-oriented databases, with emphasis given on exceptions. Constraints are restrictions on properties and relations of database objects that ensure the integrity of data. Therefore, they should be obeyed by every object, but as in real-life, there are some exceptions to this rule. Object-oriented databases provide rich semantic constructs, adequate to model real-world relations. Inheritance of constraints in object-oriented databases has been treated in a completely mandatory way, providing no room for exceptions. In this paper, an object-oriented constraint representation scheme is presented, along with a methodology for modelling constraint exceptions. Finally, an algorithm is described that ensures correct runtime resolution of constraint applicability. Since business is not in abstract, but in real-world, business database modelling would be greatly benefited from a tool that allows both a clear definition and an efficient enforcement of constraints with exceptions.

Integrity repair is a pragmatic alternative to integrity checking, already proposed by relational and Codasyl standards and supported by several commercial systems, although for a small number of constraint types. This paper proposes to integrate constraint languages with the declarative specifications of their integrity repair actions. We introduce a rather powerful, predicate-based language for specifying integrity constraints, then we discuss the semantics of repair actions as computations which react to constraint violations, then we establish sufficient conditions for ensuring their termination, and finally we show how repair actions can be integrated in the SQL2 standard and implemented by means of relational triggers (written in Oracle).

In this paper we present the concept of roles as an extension to object-oriented database models in which identifiable groups of objects are allowed to evolve by assuming transient behavior, while preserving their identity. This mechanism can be used to implement multi-faceted, or polymorphic, objects by allowing the same object to be represented under different perspectives — possibly at discrete points in time — with each perspective having its own state and behavior. The concept of roles is used to implement dynamic properties and aspects of objects and provides for added modeling power and flexibility.

A normal form object-oriented entity relationship (OOER) diagram is presented to address a set of OO data modelling issues, viz. the inability to judge the quality of an OO schema, the presence of inheritance conflicts in ISA hierarchies, the lack of explicit support for different relationship types (m-n, n-ary, recursive etc.) in some OO data models and the lack of general and flexible support for views. Three approaches are described to translate good quality OO schemas from a normal form OOER diagram. The first approach translates OO schemas whose underlying OO data models support the notion of relationship. There are no undesirable redundancies in the translated schemas. The second approach provides for OO data models that do not support the notion of relationship. Some redundancies may arise because of m-n, n-ary relationships, but these can be controlled. The third approach treats each OO schema as an external schema of a conceptual schema represented by a normal form OOER diagram. Redundancies may exist at the external schema level, but no redundancies exist at the conceptual schema level.

Applying object-oriented technology to systems development is widely recognized as improving productivity and reducing system maintenance costs. At the same time, relational technology has gained leverage in most businesses. There exist already several proposals to combine object-oriented programming with relational database systems. Yet, existing approaches do not support necessary combinations of object-oriented and relational technology in concert, like reengineering of existing relational data in an object-oriented way, and adding persistence to existing object-oriented applications. COMan (Complex Object Manager) has been developed to fill this gap. The kernel architecture of COMan is based on a set of tables, called meta database, which supports the flexible mapping from a set of object classes to a relational schema and vice versa. Thus, COMan provides necessary infrastructure technology for business reengineering seeking important leverage of legacy databases.

Deductive object oriented database languages are faced with the problem of dealing with the new concepts of the object oriented approach: object identity, inheritance, method, and complex object structure. Complex object structures raise a consistency problem for derived objects. To the best of our knowledge, no method has been proposed to do a static check of the consistency of deductive programs dealing with complex objects. In this paper we propose a solution based on a deductive language, called ERCLog, for an object and relationship data model. ERCLog explicitly manages the cardinalities of the attributes of the objects and of the links between objects. This information allows the static checking of the consistency of the programs.

The overall aim of this paper is to briefly introduce our approach to temporal data modelling described as the ORES methodology. The ORES Temporal Database Management System (TDBMS), which consists of the methodology together the supporting software tools, will provide the efficient and user friendly representation and manipulation of temporal knowledge. More specifically, this paper is concerned with the definition and manipulation of temporal data at the conceptual level. It therefore concentrates on describing such a tool, namely the query language ERT-SQL, with the help of some illustrative examples.

Creative, ill-structured processes such as requirements engineering, industrial research, or design of new products share a number of properties that make it difficult to support them by current workflow or repository technology. For these processes, methods are only partially known. There is a heavy need, but little support for effective information exchange and conflict handling in the often large and heterogeneous design teams. Due to this lack of understanding and cooperation support, there is a lot of trial, error, and backtracking, often without a significant learning curve, which makes these processes extremely unpredictable and expensive. The talk identifies three key players in such a setting: the actual (knowledge) workers, their managers or process planners, and the methodology researchers which insert generic advice into process definitions. Based on an analysis of their interaction patterns, we work out precisely where current technologies fail, and identify repository-centered strategies for improving the situation.Process repositories are a means to coordinate the interaction of process definition, process planning, process generation and customization, process guidance, process tracing, and experience-based process improvement. The integration of all these tasks implies a specific architecture (components and communication patterns). It also requires rich but computer-supportable conceptual modeling formalisms.Architecture, modeling languages, and tool integration strategies of several process repositories based on the conceptual modeling environment Concept-Base are presented for illustration. Experiences from application projects in industrial engineering, software requirements engineering, pharmaceutical research, and chemical engineering substantiate the concepts and point out directions for further research and development.

Software engineering, like any other engineering field, needs to use formal methods to prove the reliability of its products and optimise their production and maintenance. In order to do that, software specification needs to be expressed in a language whose vocabulary, syntax and semantics are formally defined. These languages can be a federating formalism in information systems for data structures and dynamics. Formal specifications may then be automatically processed and software tools can be built to assist their development. Nevertheless, little effort has been devoted by research to tool support, yet such support is essential if specifications are to be used in industry. Within this perspective, we propose a support tool that uses tan extended Entity-Relationship model and a rule language as an interface for developing formal software specifications.

In this paper we briefly overview a suite of tools developed at Lawrence Berkeley Laboratory (LBL) for aiding users in defining, querying, and browsing databases developed with commercial relational database management systems (DBMS), using object-oriented constructs. These tools are based on a version of the Extended Entity-Relationship (EER) model and a query language developed by us. They allow users to deal with concise EER structures and queries rather than relational database definitions and queries which are usually large, hard to maintain, and involve terms that obscure the semantics of the application. Using the LBL/EER database tools users are insulated from the underlying DBMS, and thus can avoid learning DBMS specific concepts and query languages.

User interaction facilities are usually the weakest component of DBMS. They are typically few in number and quite impoverished when compared both to other features of DBMS and to user interaction facilities for other kinds of software. One reason for this is that adding further mechanisms requires tedious and repetitive programming effort in the context of a complex system. The Configurable Data Modelling System (CDMS) attempts to get round this problem by providing an environment in which interaction facilities can be built more easily. CDMS considers a user interaction facility to be the pairing of a conceptual data model with a concrete user interface. CDMS provides a generic data model, comprising elements for describing data structures, constraints and active values, together with one menu driven system for creating conceptual models as instances of the generic model and another for creating user interfaces to each data model thus generated. This papers describes the important features of the former system. The principal difficulty in creating such a system is achieving a clear, consistent and coherent analysis of all of the components which might be housed in a DBMS and this is discussed in the paper.

This paper describes a technique that supports Extended Entity-Relationship (EER) schema extraction from an operating relational database. In this reverse engineering context, the two major decisions that have to be taken are the assumptions on the initial schema and where data semantic is extracted from. Original aspects of our method are manifold. First, it is based on realistic assumptions, e.g., there is no constraints on the uniqueness of the attribute names. Second, the dependencies between the attributes are not supposed to be known a priori. The method starts from the database schema as stored in the DBMS dictionary, i.e., the relation names, the attribute names and their basic characteristics (uniqueness of value, not null values). Finally, semantics extraction is supported by available queries analysis. It is shown how specific kinds of query can help to build an EER schema including is-a relationships and aggregates.

In the Forward Engineering phase, the designer modifies the database conceptual schema and produces a logical and physical schema containing some “spurious” relations dictated by design tricks and DBMS's limitations. Therefore the rebuilding of the database conceptual schema from the physical database structure is a fundamental issue in the re-engineering and design recovery processes. Some proposed methodologies try to get the necessary information from the schema and from the content of the database, paying little attention to the analysis of the usage that the programs make of the data, while this can be thought as the most reliable source of information. In this paper we present an approach to the reverse engineering based on the identification of schema, primary key, SQL and procedural indicators that lead to the assertion of Prolog facts and, by some heuristic rules, to the rebuilding of the conceptual schema.

This paper presents a method for extracting a conceptual schema from a relational database. The method is based on an analysis of data manipulation statements in the code of an application using a relational DBMS. Attributes representing references between tables in the relational schema, and possible keys are determined by an analysis of join conditions in queries and view definitions. Knowledge about which attributes link tables is used to investigate the database extension in a selective manner. When the keys cannot be unambiguously determined, possible solutions are generated by the system under guidance of the user. The approach makes it possible to efficiently construct a conceptual schema from only rudimentary information.

Layering ER diagrams has been a key tool to abstract the complexity of large data schemas generated by enterprise modeling. However, the current approaches have a certain impedance between successive steps of refining (or abstracting) ER diagrams. First, most approaches do not have a well-defined correspondence between an entity at a higher level and the entity cluster at a lower level. Second, a relationship to a subentity from an entity in a higher plane is modeled using a relationship which breaks the encapsulation of the entity which contains the subentity. Clearly, it would be nice to have non-encroaching relationships to model such situations. Finally, a refinement (abstraction) step adds (deletes) encroaching relationships and thus cascades changes to the schema beyond the current entity being refined (entity cluster being abstracted).This paper presents the Leveled Entity Relationship Model which demonstrates how one may have an abstraction formalism which does satisfy the above properties.

The more application semantics are added to a conceptual model, the greater the portion of the respective application system can be generated automatically. To allow for an automatic generation, additional type-level semantics have to be specified formally, and a large number of object-level semantics have to be derived from this formal model.Form existential dependencies, existence implications, and derivation relationships, all abstraction relationships and non-abstracting derivation relationships between object types can be constructed. Their formalisation leads to three predicates that represent direct dependencies within the conceptual model. By applying three basic production rules to these predicates, the relational closure of all indirect dependencies throughout the model can be derived formally. Based on a formalisation of elementary insert, delete, and update operations, indirect dependencies are used to identify all objects throughout the system that are affected by a data manipulation.Since the set of objects that are affected by a manipulation can be derived formally, it is possible to automatically generate database triggers that implement these object-level semantics. The generation process is presented, and examples from a simplified conceptual model and procedurally extended data model of a production planning system are given.In conceptual modeling, the proposed model extensions represent important invariant properties that are consistently specified together with structural model elements. Not only tables and static integrity constraints can be automatically generated to implement structural model elements, but also data manipulation propagation triggers can be generated to implement invariant properties. Therefore, a tight integration of structural and important behavioral aspects is provided in information system design as well as implementation. Hence, formalised extended conceptual models can be regarded as a foundation of integrated information systems development.

Schema abstraction is essential in different phases of the design process. During development, it supports browsing of repositories storing design artifacts, during maintenance, it offers a support to the comprehension of large schemas documenting existing systems. In addition, abstract descriptions of reusable portions of conceptual schemas facilitate their reuse in other applications. Systematic abstraction mechanisms need further investigation. An approach to derive semiautomatically abstractions from ER schemas via schema clustering mainly based on the structure of ER schemas is presented and discussed.

We describe an approach to the coordination of application systems through the modelling and maintenance of inter-system dependencies based on application data. These dependencies are specified by a Coordination Model which comprises a Coordination Interface for each application system and a global Coordination View. A Coordination Interface describes local object types relevant for system-wide coordination. The Coordination View describes the component systems, their globally important object types and the relationships between those object types: Further, it specifies the actions to be taken to ensure global consistency thereby providing system coordination. Specifically, we describe how this approach has been used for a Computer Integrated Manufacturing (CIM) system which is based on the coordination of CIM component systems. In this CIM system, the Coordination Model is specified using the NIAM data model.

Amazonia is based on a comprehensive model that includes a characterization of the development, representation, and evaluation of the concepts employed by scientists in their modeling of both the phenomena of interest and the process of modeling itself. It builds a framework for translating our conceptual model of scientific activity into a simple, unified, computational specification. CML is very simple to use and largely declarative in nature. Virtual R-Structures provide a means of integrating external software tools and smaller code executables (in Fortran, C, Pascal etc.) very easily in the modeling environment. The tool management system provides a generic technique which allows Amazonia to “start” a subsystem (external tool) as a background “server” process and to establish the communication channels between the main system and the server process.

Research on schema integration leads to the identification of many different conflict types. Some of them received much attention and many papers proposed solutions for their resolution. However, literature usually focuses on traditional problems, whilst new kinds of schema discrepancies, due to the object orientation or the generalization concept, are not really treated. Moreover, most of the proposed methodologies and strategies only allow binary comparisons between items to be integrated.This paper discusses n-ary (also called one-many) conflicts, and particularly the three fragmentation conflict types. These conflict types need specific operators for schema comparison. We propose a simple unified language for easy specification of these conflicts, and give many different techniques to solve them. We emphasize the benefit of separating the declaration of the correspondences from the choice of resolution technique.Our discourse is illustrated with the entity-relationship model, but our solutions can be applied in any data model. We propose several conflict resolution techniques that can be applied on a concept which has the generalization (the entity type) and different techniques that must be applied on a concept which has not (the relationship type).

A logical database schema, e.g. a relational one, is an implementation of a specification, e.g. an entity-relationship diagram. Upcoming new data models and the necessity of seamless integration of databases into application programs require a cost-effective method for mapping from one data model into the other. We present an approach where the mapping relationship is divided into three parts. The first part maps the input schema into a so-called meta model. The second part rearranges the intermediate representation, and the last part produces the schema in the target data model. A prototype has been implemented on top of a deductive object base manager for the mapping of relational schemas to entity-relationship diagrams. From this, a C++-based tool has been derived that will be part of a commercial CASE environment.

As information systems are increasingly being called upon to play vital roles in organizations, conceptual modelling techniques need to be extended to relate information structures and processes to business and organizational objectives. We propose a framework which focuses on the modelling of strategic actor relationships (“A-R”) for a richer conceptual model of business processes in their organizational settings. Organizations are viewed as being made up of social actors who are intentional — have motivations, wants, and beliefs — and strategic — they evaluate their relationships to each other in terms of opportunities and vulnerabilities. The framework supports formal modelling of the network of dependency relationships among actors, and the systematic exploration and assessment of alternative process designs in reengineering. The semantics of the modelling concepts are axiomatically characterized. By embedding the framework in the Telos language, the framework can also potentially serve as an early-requirements phase tool in a comprehensive information system development environment.

System evolution and re-engineering are becoming increasingly important as the size and complexity of Information Systems continue to grow. The paper addresses the problems related to the development of abstraction mechanisms for discovering the essential conceptual schema of a system, that is, a high level description of its most significant concepts, to be used for matching and validating changes to the system.