Database Reference
In-Depth Information
very old and very strong belief that it is entity that should be in the focus of a programming and data
model while identities simply serve entities. As a consequence, there is a strong asymmetry between
entities and identities in traditional approaches to data modeling: entities have
domain-specific
structure
while identities have
platform-specific
structure. Accordingly, classes are used to model domain-specific
structure and behavior of entities while identities are provided by the underlying environment with some
built-in platform-specific structure.
The concept-oriented model treats entities and identities symmetrically so that
both
of them may have
arbitrary domain-specific structure and behavior. More specifically, it is assumed that
any element is a
couple consisting of one identity and one entity
. To model such identity-entity couples, a new construct
is introduced, called
concept
. Concept is defined as a
couple
of two classes: one identity class and one
entity class. Concept fields are referred to as
dimensions
in COM. This produces a nice yin-yang style
of balance and symmetry between two orthogonal branches - identity modeling and entity modeling. If
traditional approaches use classes to model entities then COQL uses concepts to model identity-entity
couples. The shift of paradigm is that things (data elements) are
couples
and identities are made explicit
part of the model. Informally, elements in COM can be thought of as complex numbers in mathematics
which also have two constituents manipulated as one whole.
Identity is an observable part which is manipulated directly in its original form. It is passed by-value
(by-copy) and does not have its own separate representative. Entity can be viewed as a thing-in-itself
or reality which is radically unknowable and not observable in its original form. The only way to do
something with an entity consists in using its identity as an intermediate. This means that there is no
other way to access an entity rather than using its reference.
Entities are persistent
objects
while identities are transient
values
which are used to represent and
access objects. In most cases identities are immutable and cannot be changed over the whole lifetime
of the represented entity while entities are supposed to be mutable so that their properties reflect the
current state of the problem domain. The entity itself is then considered a kind of a point in space while
its reference is thought of as a coordinate. It is important to note that references in COM are abstract
addresses from a virtual address space. Therefore the represented object can actually reside anywhere in
the world (not even necessarily in a computer system). References in COM (just as values) are
domain-
specific
because they are designed taking into account properties and requirements of the application
being created. In contrast, references in most existing models are
platform-specific
because they are
provided by the compiler taking into account the available run-time environment.
If identity class of a concept is empty then this concept is equivalent to conventional class which
is used for describing objects. In this case entities are supposed to be represented by some platform-
specific reference. If entity class is empty then this concept describes a type of values (value domain).
Values are very important notion in data modeling because they are considered terminal elements for
any model. Essentially, values are what any model or computation is about. Values are characterized by
the following properties: they are immutable, passed by-copy, do not have their own reference. Values
are used in modeling because they have some meaning which can be passed to other elements, stored,
retrieved or computed. An example of a primitive value is an integer number which could represent city
population or a double number which could represent the quantity of some resource. A complex system
requires complex value types which are made of simpler types and it is precisely where concepts (with
empty entity class) are intended to be used. For example, the following concept describes amount in
some currency (like USD or EUR) as a value:
