A common aim of data modeling approaches is to produce schemas whose instantiations are always redundancy-free. This is especially useful when the implementation target is a relational database. This paper contrasts two very different approaches to attain a redundancy-free relational schema. The Object-Role Modeling (ORM) approach emphasizes capturing semantics first in terms of atomic (elementary or existential) fact types, followed by synthesis of fact types into relation schemes. Normalization by decomposition instead focuses on “nonloss decomposition” to various, and progressively more refined, “normal forms”. Nonloss decomposition of a relation requires decomposition into smaller relations that, upon natural join, yield the exact original population. Nonloss decomposition of a table scheme (or relation variable) requires that the decomposition of all possible populations of the relation scheme is reversible in this way. In this paper we show that the dependency requirement for “all possible populations” is too restrictive for definitions of multivalued and join dependencies over relation schemes. By exploiting modeling heuristics underlying ORM, we offer better definitions of these data dependencies, and of “nonloss decomposition”, thus enabling these concepts to be addressed at a truly semantic level.

A business domain is typically constrained by business rules. In practice, these rules often
include constraints of different modalities (e.g. alethic and deontic). Alethic rules impose
necessities, which cannot, even in principle, be violated by the business. Deontic rules impose
obligations, which may be violated, even though they ought not. Conceptual modeling approaches
typically confine their specification of rules to alethic rules. This paper discusses one way to
model deontic rules, especially those of a static nature. A formalization based on modal operators
is provided, and some challenging semantic issues are examined from both logical and pragmatic
perspectives. Because of its richer semantics, the main graphic notation used is that of Object-
Role Modeling (ORM). However, the main ideas could be adapted for UML and ER as well. A basic
implementation of the proposed approach has been prototyped in a tool that supports automated
verbalization of both alethic and deontic rules.

Some information modeling approaches allow instances of relationships
or associations to be treated as entities in their own right. In the
Unified Modeling Language (UML), this modeling technique is called
“reification”, and is mediated by means of association classes. In
Object-Role Modeling (ORM), this process is called “objectification” or
“nesting”. While this modeling option is rarely supported by industrial
versions of Entity-Relationship Modeling (ER), it is allowed in several
academic versions of ER. Objectification is related to the linguistic
activity of nominalization, of which two flavors may be distinguished:
circumstantial; and propositional. In practice, objectification needs to
be used judiciously, as its misuse can lead to implementation anomalies,
and those modeling approaches that permit objectification often provide
incomplete or flawed support for it. This paper provides an in-depth
analysis of objectification, shedding new light on its fundamental nature,
and providing practical guidelines on using objectification to model
information systems. Because of its richer semantics, the main graphic
notation used is that of ORM 2 (the latest generation of ORM). However,
the main ideas are relevant to UML and ER as well.

While some information modeling approaches (e.g. the Relational Model,
and Object-Role Modeling) are typically formalized using first-order
logic, other approaches to information modeling include support for
higher-order types. There appear to be three main reasons for requiring
higher-order types: (1) to permit instances of categorization types to be
types themselves (e.g. the Unified Modeling Language introduced power
types for this purpose); (2) to directly support quantification over sets
and general concepts; (3) to specify business rules that cross
levels/metalevels (or ignore level distinctions) in the same model. As the
move to higher-order logic may add considerable complexity to the task of
formalizing and implementing a modeling approach, it is worth
investigating whether the same practical modeling objectives can be met
while staying within a first-order framework. This paper examines some key
issues involved, suggests techniques for retaining a first-order
formalization, and also makes some suggestions for adopting a higher-order
semantics.

Unlike UML and some ER versions, ORM currently allows a fact type to be
objectified only if it either has a spanning uniqueness constraint or is a
1:1 binary fact type. This article argues that this restriction should be
relaxed, and replaced by a modeling guideline that allows some n-ary
associations to be objectified even if their longest uniqueness constraint
spans n-1 roles. The pros and cons of removing this restriction are
discussed, and illustrated with examples.

Many application domains involve constraints that, at a conceptual
modeling level, apply to one or more schema paths, each of which involves
one or more conceptual joins (where the same conceptual object plays roles
in two relationships). Popular information modeling approaches typically
provide only weak support for such join constraints. This paper contrasts
how join constraints are catered for in Object-Role Modeling (ORM), the
Unified Modeling Language (UML), the Object-oriented Systems Model (OSM),
and some popular versions of Entity-Relationship modeling (ER). Three main
problems for rich support for join constraints are identified:
disambiguation of schema paths; disambiguation of join types; and mapping
of join constraints. To address these problems, some notational,
metamodel, and mapping extensions are proposed.

Database schemas are best designed by mapping from a high level,
conceptual schema expressed in human-oriented concepts. While conceptual
schemas are often specified using entity relationship modeling (ER), a
more natural and expressive formulation is often possible using Object
Role Modeling (ORM). This approach views the world in terms of objects
playing roles, and traditionally expresses all information in terms of
elementary facts, constraints and derivation rules. Although verbalization
in terms of elementary facts has many practical and theoretical
advantages, it is difficult to define the notion precisely. This paper
examines various awkward but practical cases which challenge the
traditional definition. In so doing, it aims to clarify what elementary
facts are and how they can be best expressed.

Subtyping is an important feature of semantic approaches to
conceptual schema design and, more recently, object-oriented database
design. However the relational model does not directly support subtyping,
and CASE tools for mapping conceptual to relational schemas typically
provide only very weak support for mapping subtypes. This paper surveys
some of the main issues related to conceptual specification and relational
mapping of subtypes, and indicates how Object Role Modeling solves the
associated problems.

Although entity relationship (ER) modeling techniques are commonly used
for information modeling, Object Role Modeling (ORM) techniques are
becoming increasingly popular, partly because they include detailed design
procedures providing guidelines for the modeler. As with the ER approach,
a number of different ORM techniques exist. In this paper, we propose an
integration of two theoretically well founded ORM techniques: FORM and
PSM. Our main focus is on a common terminological framework, and on the
notion of subtyping. Subtyping has long been an important feature of
semantic approaches to conceptual schema design. It is also the concept in
which FORM and PSM differ the most in their formalization. The subtyping
issue is discussed from three different viewpoints covering syntactical,
identification, and population issues. Finally, a wider comparison of
approaches to subtyping is made, which encompasses other ER-based and
ORM-based information modeling techniques, and highlights how formal
subtype definitions facilitate a comprehensive specification of subtype
constraints.

In information systems modeling, the business domain being modeled often exhibits subtyping aspects that can prove challenging to implement in either relational databases or object-oriented code. In practice, some of these aspects are often handled incorrectly. This paper examines a number of subtyping issues that require special attention (e.g. derivation options, subtype rigidity, subtype migration), and discusses how to model them conceptually. Because of its richer semantics, the main graphic notation used is that of Object-Role Modeling (ORM). However, the main ideas could be adapted for UML and ER, so these are also included in the discussion. A basic implementation of the proposed approach has been prototyped in an open-source ORM tool.

An application structure is best modeled first as a conceptual
schema, and then mapped to an internal schema for the target DBMS.
Different but equivalent conceptual schemas often map to different
internal schemas, so performance may be improved by applying conceptual
transformations prior to the standard mapping. This paper discusses recent
advances in the theory of schema transformation and optimization within
the framework of ORM (Object Role Modeling). New aspects include object
relativity, complex types, a high level transformation language and update
distributivity.

Flat graphical, conceptual modeling techniques are widely accepted as
visually effective ways in which to specify and communicate the conceptual
data requirements of an information system. Conceptual schema diagrams
provide modelers with a picture of the salient structures underlying the
modeled universe of discourse, in a form that can readily be understood by
and communicated to users, programmers and managers. When complexity and
size of applications increase, however, the success of these techniques in
terms of comprehensibility and communicability deteriorates rapidly. This paper proposes a method to offset this deterioration, by adding
abstraction layers to flat conceptual schemas. We present an algorithm to
recursively derive higher levels of abstraction from a given (flat)
conceptual schema. The driving force of this algorithm is a hierarchy of
conceptual importance among the elements of the universe of discourse.

This paper proposes extensions to the Object-Role Modeling approach to support schema transformations that eliminate unneeded columns that may arise from standard relational mapping procedures. A “unique where true” variant of the external uniqueness constraint is introduced to allow roles spanned by such constraints to occur in unary fact types. This constraint is exploited to enable graphic portrayal of a new corollary to a schema transformation pattern that occurs in many business domains. An alternative transformation is introduced to optimize the same pattern, and then generalized to cater for more complex cases. The relational mapping algorithm is extended to cater for the new results, with the option of retaining the original patterns for conceptual discussion, with the transforms being applied internally in a preprocessing phase. The procedures are being implemented in NORMA, an open-source tool supporting the ORM 2 version of fact-oriented modeling.

Collection types such as sets, bags and arrays have been used as data
structures in both traditional and object oriented programming. Although
sets were used as record components in early database work, this practice
was largely discontinued with the widespread adoption of relational
databases. Object-relational and object databases once again allow
database designers to embed collections as database fields. Should
collections be specified directly on the conceptual schema, as mapping
annotations to the conceptual schema, or only on the logical database
schema? This paper discusses the pros and cons of different approaches to
modeling collections. Overall it favors the annotation approach, whereby
collection types are specified as adornments to the pure conceptual schema
to guide the mapping process from conceptual to lower levels. The ideas
are illustrated using notations from both object-oriented (Unified
Modeling Language) and fact-oriented (Object-Role Modeling) approaches.

This paper proposes an extension to the Object-Role Modeling approach to support formal declaration of dynamic rules. Dynamic rules differ from static rules by pertaining to properties of state transitions, rather than to the states themselves. In this paper, application of dynamic rules is restricted to so-called single-step transactions, with an old state (the input of the transaction) and a new state (the direct result of that transaction). Such restricted rules are easier to formulate (and enforce) than a constraint applying historically over all possible states. In our approach, dynamic rules specify an elementary transaction type indicating which kind of object or fact is being added, deleted or updated, and (optionally) pre-conditions relevant to the transaction, followed by a condition stating the properties of the new state, including the relation between the new state and the old state. These dynamic rules are formulated in a syntax designed to be easily validated by non-technical domain experts.

This paper provides formal semantics for an extension of the Object-Role Modeling approach that supports declaration of dynamic rules. Dynamic rules differ from static rules by pertaining to properties of state transitions, rather than to the states themselves. In this paper we restrict application of dynamic rules to so-called single-step transactions, with an old state (the input of the transaction) and a new state (the direct result of that transaction). These dynamic rules further specify an elementary transaction type by indicating which kind of object or fact (being added, deleted or updated) is actually allowed. Dynamic rules may declare pre-conditions relevant to the transaction, and a condition stating the properties of the new state, including the relation between the new state and the old state. In this paper we provide such dynamic rules with a formal semantics based on sorted, first-order predicate logic. The key idea to our solution is the formalization of dynamic constraints as static constraints on the database transaction history.

One difficult task in information modeling is to adequately address the impact of time. This paper briefly reviews some popular approaches for modeling temporal data and operations, then provides a conceptual framework for classifying temporal information, and proposes data model patterns to address time-impacted tasks such as modeling histories, and tracking entities across time as they migrate between roles. Special attention is given to capturing the relevant business rules. While the data modeling discussion focuses on Object-Role Modeling (ORM), many of the basic principles discussed can be adapted to other approaches such as Entity Relationship Modeling (ER) and the Unified Modeling Language (UML).

In the analysis phase of information systems development, it is important to have the conceptual schema validated by the business domain expert, to ensure that the schema accurately models the relevant aspects of the business domain. An effective way to facilitate this validation is to verbalize the schema in language that is both unambiguous and easily understood by the domain expert, who may be non-technical. Such verbalization has long been a major aspect of the Object-Role Modeling (ORM) approach, and basic support for verbalization exists in some ORM tools. Second generation ORM (ORM 2) significantly extends the expressibility of ORM models (e.g. deontic modalities, role value constraints, etc.). This paper discusses the automated support for verbalization of ORM 2 models provided by NORMA (Neumont ORM Architect), an open-source software tool that facilitates entry, validation, and mapping of ORM 2 models. NORMA supports verbalization patterns that go well beyond previous verbalization work. The verbalization for individual elements in the core ORM model is generated using an XSLT transform applied to an XML file that succinctly identifies different verbalization patterns and describes how phrases are combined to produce a readable verbalization. This paper discusses the XML patterns used to describe ORM constraints and the tightly coupled facilities that enable end-users to easily adapt the verbalization phrases to cater for different domain experts and native languages.

Two major problems in constructing data federations (for example, data warehouses and database federations) concern achieving and maintaining consistency and a uniform representation of the data on the global level of the federation. The first step in creating uniform representations of data is known as data extraction, whereas data reconciliation is concerned with resolving data inconsistencies. Our approach to constructing a global conceptual schema as the result of integrating a collection of (semantically) heterogeneous component schemas is based on the concept of exact views. We show that a global schema constructed in terms of exact views integrates component schemas in such a way that the global schema is populated by exactly those instances allowed by the local schemas (and in special cases, also the other way around). In this sense, the global schema is equivalent to the set of component schemas from which the global schema is derived. This paper describes a modeling framework for data federations based on the Object-Role Modeling (ORM) approach. In particular, we show that we can represent exact views within ORM, providing the means to resolve in a combined setting data extraction and reconciliation problems on the global level of the federation.