Object-Role Modeling (ORM) is a framework for modeling and querying information at the conceptual level. It comes to support the design of large-scale industrial applications allowing the users to model easily the domain. The reasoning on a conceptual schema enables to automatically detect relevant formal properties, such as inconsistencies or redundancies that cause a degradation of the quality of the design and an increase of development times and costs. In this demonstration we introduce NORMA, a tool which implements the ORM language and its plugin ORMIe, which performs the reasoning on ORM conceptual schema in order to help the modeler during the modeling phase to avoid mistakes that could lead the software to unexpected behaviors.
Conceptual modeling is a critical step during the development of a database system. It is the detailed description of the universe of discourse in a language that is understandable by users of the business domain. Object-Role Modeling (ORM) is a conceptual language for modeling, which includes a graphical (ORM’s graphical notation) and textual language (FORML) for specifying models, a textual language for formulating queries, as well as procedures for constructing ORM models, and mapping to other kinds of models like UML and ER. ORM is fact-oriented, i.e., it models the information in a way that it can be verbalized using sentences that are easily understandable by domain experts and even for those who are not familiar with IT in general. The expressiveness of the ORM constructs may lead to implicit consequences that can go undetected by the designer in complex schemas; this may also lead to various forms of inconsistencies or redundancies in the diagram itself that give rise to the degradation of the quality of the design and/or increased development times and costs. This issue leads to the need of automated reasoning to check the mentioned inconsistencies and redundancies. NORMA is the tool that implements the ORM language and ORMIe is a plugin for NORMA which enables the automated reasoning on ORM conceptual schemas. Of particular interest are the Derivation Rules, they are special ORM constructs which are able to express knowledge that is beyond the ORM capabilities. The current version of ORMIe is able to perform reasoning on a subset of such Derivation Rules.
ORM stands for Object-Role Modeling. It is a language that allows users to model and
query information at the conceptual level and the world is described in terms of objects
(things) playing roles (parts in relationships) [
Two software that implement the reasoning are ICOM [
NORMA is the tool that implements the ORM language, it has been developed by
Terry Halpin and Matthew Curland, [
ORM main features are: formalized, it has a clear syntax and semantics; graphical, has an official software (NORMA) that makes possible to express the conceptual schema in an easy graphical way, like the examples shown in this paper; fact-oriented, all facts and rules are modeled in terms of controlled natural language (FORML), sentences easy to understand even for non-technical users; attribute-free, unlike ER and UML, it is more stable and adaptable to changing business requirements.
The following examples show how NORMA works and implements ORM. We show only the very basic ORM constructs to simplify the general understanding. In Figure 1a we have an ORM conceptual schema with some entities: Person, Male, Female, Husband and Wife. Male and Female are subentities of Person in disjoint and covering. Husband is subentity of Male and Wife is subentity of Female. Name is an entity value which means a collection of data types (string, int, etc.). The relations are depicted with the tiny rectangle boxes. The arity depends on the number of boxes (roles) and consequently of (a) ORM schema.
(b) ORM schema verbalization. role players (entities). Smokes is a unary relation that is exactly like the boolean value in a SQL column true/false. Has and marriage instead are binary relations. The fact-oriented approach facilitates the understanding of the ORM conceptual schema in a way that even the non-technical users can easily understand the semantics of the schema, since it is expressed in controlled natural language; this approach helps also the modeler during the validation of the schema to detect errors. This feature is implemented in NORMA by ORM Verbalization Browser, as shown in Figure 1b.
ORMIe stands for ORM Inference Engine and it is a NORMA plugin that performs
reasoning on ORM schemas. Reasoning helps the modeler to detect relevant formal
properties of the schema that may be undetected during the modeling phase which give rise
to the software quality degradation and/or increased development times and costs.
Especially with large software this is helpful to understand if and why the schema could have
some inconsistencies, redundancies and unexpected behaviors. The reasoning services in
ORM are due to off-the-shelves reasoners developed by the Description Logics
community. As in [
In Figure 2a we can see an example on how this can help the modeler during the modeling phase. The ORM conceptual schema contains the entity Italian and its subentities: LatinLover, Lazy and Mafioso, that are in covering and disjoint. Then, we also have another subentity called ItalianProf, which is in disjointed with Lazy and Mafioso. Considering that the covering and the disjointness of the Italian set is made by LatinLover, Lazy, Mafioso and that ItalianProf cannot be Lazy and Mafioso, we can conclude that all the objects in ItalianProf must also be objects of LatinLover. The result of the reasoning is shown in Figure 2b.
ORM is enriched with Derivation Rules that are of particular interest for our demonstration, because they are able to express knowledge that is beyond ORM capabilities and (a) ORM conceptual schema without reasoning.
(b) ORM conceptual schema with reasoning. to derive new information from other information, similar to triggers, stored procedures and views in SQL. In NORMA these rules are expressed in FORML, which is a controlled natural language. This means that Derivation Rules are well structured and they have a precise syntax. This syntax has been studied and enriched with an unambiguous semantics, so it was possible to catch the encoding in ALCQI and consequently in OWL.
In Figure 3a there is an example of an ORM conceptual schema with 3 Derivation Rules (depicted with an asterisk in the entities and a textbox):
Bird is an Animal that flies and doesn’t swim; Fish is an Animal that swims and doesn’t fly;
Shark is an Animal that swims, doesn’t fly and is dangerous.
Since all the objects in Bird fly and never swim and vice versa for those that are in Fish, it is pretty clear that a bird cannot be a fish and vice versa, so this constraint leads to the disjointness between the corresponding entities. The entity Shark is a specialization of the entity Fish, because it has the same properties of Fish, but it is also “dangerous”. This leads to the inferred constraints in Figure 3b.
Derivation Rules can be placed on subtype entities and also on relations. Until now, ORMIe covers reasoning only for Subtype Derivation Rules.
We presented ORM, a modeling language used to design diagram at the conceptual level. ORM is implemented in NORMA, an advanced conceptual modeling tool that extended with the plugin ORMIe is able to perform automated reasoning to support the conceptual modeling phase during the development of the software lifecycle. We demonstrated, by means of examples, the importance of the reasoning since it provides implicit information which can be undetected during the modeling phase. This approach helps the modeler to preserve the quality of the conceptual schema and to avoid mistakes that could lead the software to unexpected behaviors.
The research and development of NORMA continues on two tracks: we are keeping studying the formalization of Derivation Rules in order to cover binary relations as well; we are currently considering to implement the explanation service, which could help the modeler to understand the reason behind mistakes that may occur during the modeling phase.