Learning Center
Plans & pricing Sign in
Sign Out

IKE Set theoratic data model UBICC 187


UBICC, the Ubiquitous Computing and Communication Journal [ISSN 1992-8424], is an international scientific and educational organization dedicated to advancing the arts, sciences, and applications of information technology. With a world-wide membership, UBICC is a leading resource for computing professionals and students working in the various fields of Information Technology, and for interpreting the impact of information technology on society.

More Info

                          E. J. Yannakoudakis, P. K. Andrikopoulos
               Athens Univ. of Economics and Business, Department of Informatics
                                     Athens 10434, Greece
                                    {eyan, padrik}

             The paper presents an integrated set-theoretic data model that offers a framework
             for defining a unified schema for any database environment. We utilise the concepts
             ”entity” in its classical meaning, ”tag” as a set of properties (attributes) which can
             describe an entity, ”subtag” as a set of simple atomic attributes which cannot be
             decomposed further, ”domain” as a set of well-defined values that can be derived
             from pre-specified data types, ”language”, ”vocabulary” and ”message” as strings
             or coded values that represent human languages and corresponding messages. The
             model described can manage efficiently changes that occur at the logical level and
             supports operations and functions that offer solutions to well-known problems faced
             by database designers and programmers alike. Typical problems solved include the
             retention of multiple schema versions, the maintenance of authority files, the support
             of repeatable attributes, the processing of multilingual databases (at both data and
             interface levels).

             Keywords: data models, databases, schema evolution

1   INTRODUCTION                                           schema. Thus, all valid instances of the old database
                                                           schema will become valid instances of the new data-
     The evolution of database schemata is becoming        base schema and new versions of the software can ac-
a very serious problem, especially with the advent of      cess old data [3]. Despite supporting backward com-
large distributed databases. Continuous modifications       patibility schema evolution fails to form an effective
of a database schema are necessary due to (a) the fact     technique because data conversion is feasible when
that the applications are continuously changing, (b)       the scale is small and when the changes are simple.
the perspective experience from using a system that        As the scale of the application increases the problem
induces changes to desired functionality and (c) the       becomes more complicated and confusing.
scale of many tasks that require incremental design.            In schema versioning the old schema and its cor-
Sjoberg addressed the problem in practice by using         responding data are preserved, but a new version
a method for quantifying schema changes and pro-           of the schema is created, which incorporates all the
posed a tool that automates modification procedures         desired changes [4]. The different versions of the
[1]. Nowadays, the problems of schema evolution and        schema can be identified and selected by a suitable
schema versioning still form common issues of re-          labelling system, such as symbolic naming, or time
search in the context of database applications which       stamping (transaction time of schema changes).
are destined to have a long lifetime.                           Despite attaining continued support of legacy ap-
     According to a widely accepted terminology,           plications, the accommodation of schema versioning
schema evolution is accommodated when a database           presents various open problems related to the update
system facilitates the modification of the database         of data through historical schemata [3]. Organizing all
schema without loss of existing data, whereas schema       schema versions that arise from previous evolutions
versioning is accommodated when a database sys-            in order to cope with how applications can access the
tem allows the accessing of all data, both retrospec-      data in a versioned schema environment, besides the
tively and prospectively, through user definable ver-       considerable time and effort required for implementa-
sion interfaces [2]. Schema evolution implies that ex-     tion [5], gives rise to high computational costs.
tant data will be converted from the old to the new             In relational database systems the main problem
addressed is that of change propagation. Change             sets.
propagation is commonly accomplished by populat-                 A set is a collection of objects; order is not taken
ing the new schema version with the results of queries      into account [14]. The elements making up a set are
involving extant data connected to previous schema          assumed to be distinct. Given a description of a set X
versions [6]. This procedure encounters significant          and an element x, we can determine whether or not x
performance problems on transforming existing data          belongs to X. If x is in the set X, we write x ∈ X, and
to meet the evolved specifications and requires much         if x is not in X, we write x ∈ X.
memory space as the database evolves.                            Every set is a subset of the set U, called a univer-
     In the object-oriented field, where schema ver-         sal set or universe, which must be explicitly given or
sioning is usually regarded as the versioning of classes    inferred from the context. In the definitions that fol-
that constitute a schema [7] [8], the problems are even     low we attempt to define every universal set, so that it
more serious. Although there are some techniques            can be used as a frame of reference to every set of our
to handle the derivation of classes and the navigation      model.
through versions [9], there are still open issues at the    2.1    Languages, Vocabulary Items and Messages
point of polymorphism and inheritance. For example,              Let us define UL as the universal set of all spoken
the ability to distinguish between two kinds of inheri-     languages supported by the Unicode standard and UV
tance (inheritance between classes and inheritance be-      the universal set of all words and phrases supported
tween versions) is still not fully explored [10].           by any Unicode writing system. Certainly there is a
     Experience shows that supporting schema evolu-         meaning behind every element of the UV set. That
tion by creating new schema versions and using data         helps us define UM as the universal set of the semantics
transformation mechanisms is a hard task. A more            of the UV set. This consideration is the first step to-
sophisticated solution to this problem could be the         wards the implementation of multilingual operations,
implementation of a unified schema with the ability          while adopting the following definitions:
to handle frequently changes that occur with evolv-            • Set of Languages L ⊆ UL is the unordered set
ing database environments without the need for cor-               of all registered languages. That is, all the lan-
responding modifications at either logical or physical             guages which are currently supported.
levels. In this direction, Yannakoudakis proposed a
                                                               • Set of Vocabulary Items V ⊆ UV is the unordered
Framework for a DataBase (FDB) for defining a uni-
                                                                  set of registered words and phrases, which can
fied schema with the ability for self-propagation of
                                                                  be used for naming data elements in a specific
the stored data [11][12]. In FDB, the main empha-
                                                                  language l ∈ L.
sis of the research has been the establishment of a
structure, offering dynamically evolving database en-          • Set of Messages M ⊆ UM is the unordered set of
vironments which encapsulate frequently encountered               the semantics of the V element and can be used
changes, by utilizing metadata. A similar method has              to assign conceptual meanings to data elements.
been used by Grandi [13] for mapping attributes and               That is, to name data elements in a language of
tables by adopting a multi-pool schema versioning ap-             the universe of discourse.
proach.                                                          According to the above definitions a language l
     In this paper we propose an integrated set-            is currently supported if l ∈ L or is not supported if
theoretic data model that offers a framework for defin-      l ∈ {x ∈ UL |¬(x ∈ L)}. Similarly, a message m ∈ M is
ing a structure (unified schema) that eliminates com-        a registered message that can be used and v ∈ V is a
pletely the need for reorganization at the logical level.   registered vocabulary item that can also be used.
The basis for the creation of the unified schema is the           Matching vocabulary items with a message is per-
definition and manipulation of metadata that compose         formed by the Smsg function. Functions are used ex-
the whole structure. The scope of this paper is to de-      tensively in discrete mathematics to assign to each
scribe explicitly the features of the unified schema, de-    member of a set X exactly one member of a set Y .
fine metadata and the operations on the metadata.            The binary function Smsg from DSmsg to V is a rela-
                                                            tion that each element of DSmsg ⊆ M × L is associated
     The remainder of this paper is organized in four
                                                            with a unique element of V . The Smsg function can
sections. Section 2 describes the structure of the pro-
                                                            be used to translate any message into any supported
posed model by defining the unified schema. Section 3
exhibits some of the basic operations for manipulating
metadata that compose the unified schema, Section 4          2.2  Domains
illustrates the model with an example, and Section 5           We define UD as the universal set of every data
concludes the paper.                                        domain that can be defined for storing information.
                                                            Based on the above:
                                                              • Set of domains D ⊆ UD is the unordered set of
    The definition of the basic elements of our model            registered domains, which determine all possible
is based on the mathematical theory of (unordered)              values of every data element in our model.
     If a domain d is defined, then d ∈ D holds and           introducing the logical structure by defining metadata,
d can be assigned to a data element. A domain d ∈ D          it is important to note that tags can only receive val-
specifies a primitive datatype value and a length value.      ues from a specific domain. The function Tdom from
These properties are defined by the functions Dtype           DT dom ⊆ T to D is a relation whereby each element of
and Dlen. The function Dtype from DDtype = D to              T is associated with a unique element of D. A com-
Q = {int, char, real, bool, blob} is a relation whereby      plex tag has no domain, because its domain is speci-
each element of D is associated with a unique element        fied by the domains of its subtags.
of Q. The function Dlen from DDlen = D to N is a                    Every simple tag has an occurrence status. It can
relation whereby each element of D is associated with        either be optional or mandatory. A mandatory tag
a natural number which determines the data length in         must always contain a value that is not null. This fea-
bytes.                                                       ture of a tag is defined by the Tocc function. The func-
                                                             tion Tocc from DTocc ⊆ T to O = {0, 1|0 : Optional, 1 :
2.3    Entities
                                                             Mandatory} is a relation whereby each element of T
     We define UE as the universal set of distinct and
                                                             is associated with a unique element of O. A complex
autonomous objects, forming what we generally call
                                                             tag has no occurrence status, as it has no domain.
”entity”. An entity need not have a material existence.
                                                                    Every tag has a repetition status which can be ei-
In particular, abstractions and legal functions are usu-
                                                             ther single-valued or multi-valued. A single-valued
ally regarded as entities. Based on this we define:
                                                             tag must always contain a singe value for a given sam-
   • Set of Entities E ⊆ UE is the unordered set of          ple of an entity e. However, multi-valued tags can re-
      registered entities that participate in the logical    ceive multiple values for the same sample of an en-
      schema of our model.                                   tity. The repetition status of a tag is defined by the
     For every entity e that has been created and is cur-    Trep function. The function Trep from DTrep = T to
rent in the logical schema the expression e ∈ E holds.       R = {0, 1|0 : Single − valued, 1 : Multi − valued} is a
Also, every entity in the logical schema has a single        relation whereby each element of T is associated with
unique name. The function Enam from DEnam =E to              a unique element of R.
M is a relation whereby each element of E is asso-                  Tags from different entities may reference one an-
ciated with a unique element of M, naming in effect          other, provided they receive values from the same do-
each entity. Note that Enam is an one-to-one function        main. Every tag has an authority status that deter-
so it has an inverse function Enam−1 .                       mines its participation in a relation. The authority
2.4    Tags                                                  status of a tag is defined by the Taust function. The
     We define UT as the universal set of all particular      function Taust from DTaust = T to A = {0, 1, 2|0 : No−
properties (attributes) that can feature any entity of the   participation, 1 : Authority−Tag, 2 : Selected −Tag}
model. Based on this:                                        is a relation whereby each element of T is associated
   • Set of Tags T ⊆ UT is the unordered set of prop-        with a unique element of A. References between tags
      erties that exist in our logical schema and feature    are performed by the Auth function from DAuth ⊂ T
                                                             to T = {t|Taust(t) = 1,t ∈ T }. For example, let us
      its entities.
                                                             assume that tag tA1 of a given entity A references
     Tags can be simple or complex. For every tag t
                                                             tag tB1 of entity B and tags tB2 , tB3 from B are se-
that has been created and currently exists in the logical
                                                             lected for presentation. That is, Auth(tA1 ) = tB1 where
schema the expression t ∈ T holds.
                                                             Taust(tB1 ) = 1 and Taust(tB2 ) = Taust(tB3 ) = 2
     Every tag resides in (at most) one entity. Entity-
tag associations are performed by the Tent function.         2.5    Subtags
This function from DTent =T to E is a relation whereby            We define US as the universal set of all possible
each element of T is associated with a unique element        simple (atomic) attributes that can constitute any com-
of E.                                                        plex tag.
     Every tag has a name assigned through the Tnam             • Set of Subtags S ⊆ US is the unordered set of reg-
function. The function Tnam from DT nam =T to M is a               istered attributes that exist in our logical schema,
relation whereby each element of T is associated with              which constitute existing complex tags.
a unique element of M.                                            For every subtag s that has been created and cur-
     Note that the Tnam function is not one-to-one,          rently resides in the logical schema the expression
because two different tags may have the same name.           s ∈ S holds.
However, a tag’s name has to be different from any                Every subtag is part of one and only tag. This
other tag’s name in the same entity.                         association is performed by the Stag Function. The
     Every simple tag t ∈ T holds data of the same           function Stag from DStag =S to T is a relation whereby
kind, which are singularly associated with every in-         each element of S is associated with a unique element
stance of the entity e = Tent(t) where tag t resides.        of T .
Although data storage and manipulation are not dis-               Every subtag necessarily has a name. The nam-
sertated in this model description that emphasizes on        ing of subtags is performed by the Snam function.
The function Snam from DSnam =S to M is a relation         the function returns the element v; otherwise, it re-
whereby each element of S is associated with a unique      turns the empty set.
element of M.                                                SelectVocItem()
     The Snam function is not one-to-one, because two        x := 0/
different subtags may have the same name. However,            ¯
                                                             V := V
a subtag’s name has to be different from any other sub-      do ∀v ∈ V ¯
tag’s name in the same tag.                                       display(v)
     Subtags can only receive values from a specific               read(choice)
domain, similarly to tags. The function Sdom from                 if choice = ”select” then
DSdom = S to D is a relation whereby each element of                     x := {v}
S is associated with a unique element of D.                              V := 0
                                                                          ¯     /
     Every subtag has also an occurrence status. It               end if
can either be optional or mandatory, and is defined           end do
by the Socc function. This function from DSocc = S           return(x)
to O = {0, 1|0 : Optional, 1 : Mandatory} is a relation       3.1.3 Update message
whereby each element of S is associated with a unique           This function updates message properties. It
element of O.                                              enables the manipulation of the vocabulary items
     Every subtag has also a repetition status. It can     of a message in every language.               If an up-
either be single-valued or multi-valued, and is defined     date is effected, the function returns the updated
by the Srep function. This function from DSrep = S to      message m; otherwise, it returns the empty set.
R = {0, 1|0 : Single − valued, 1 : Multi − valued} is a      U pdateMessage(m)
relation whereby each element of S is associated with        x := 0/
a unique element of R.                                       do ∀l ∈ L
                                                                  read (choice)
                                                                  case choice of
     The creation and management of the structure de-             ”edit”:
fined in the previous section is based on operations                                            /
                                                                         if DSmsg ∩ {(m, l)} = 0 then
that perform metadata manipulation. These operations                           DSmsg := {(m, l)} ∪ DSmsg
affect the basic sets and the functions, as well as do-                  end if
mains and values.                                                        v := SelectVocItem()
     Generally, the types of operations are add, delete,                          /
                                                                         if v = 0 then
rename, update and select. Add operation adds a new                                          /
                                                                               do while z := 0
set element. Delete operation deletes an element from                               read(v)
a set. Rename operation changes the alphanumeric                                    z := AddVocItem(v)
code or the abbreviation used for an element notation.                         end do
Update operation is used in more complex sets (e.g.                      end if
Tags) for updating any of their features. Finally, se-                   Smsg(m, l) := v
lect operation enable us to select a set element.                        x := m
     In what follows we present the algorithm of some             ”delete”:
typical operations.                                                      DSmsg := ¬{(m, l)} ∩ DSmsg
                                                                         x := m
3.1 Languages, Vocabulary Items and Messages
                                                                  end case
   3.1.1 Add language
                                                             end do
     This function inserts a new element l in Lan-
guages set L. If addition succeeds the function returns    3.2 Domains
the modified L; otherwise, it returns the empty set.           3.2.1 Select domain
  AddLanguage(l)                                                This function enables the user to select an ele-
  x := 0/                                                  ment d from Domains set D. If a selection is made, the
  if {l} ∩ L = 0 then                                      function returns the element d; otherwise, it returns
        L := L ∪ {l}                                       the empty set.
        x := L                                               SelectDomain()
  else                                                       x := 0/
        display(”language l exists”)                          ¯
                                                             D := L
  end if                                                     do ∀d ∈ D ¯
  return(x)                                                       display(d, Dtype(d), Dlng(d))
   3.1.2 Select vocabulary item                                   read(choice)
     This function enables the user to select an element          if choice = ”select” then
v from Vocabulary Items set V. If a selection is made,                  x := {d}
           D := 0
            ¯                                                DelEntity(e)
      end if                                                 x := 0/
 end do                                                      if {e} ∩ E = {e} then
 return(x)                                                          ¯
                                                                  T := {y|Tent(y) = e}
  3.2.2   Delete domain                                                                                       /
                                                                  if (DAuth ∩ T ) ∪ {t|Taust(t) = 0,t ∈ T } = 0 then
                                                                              ¯                         ¯
                                                                       do ∀t ∈ T ¯
     This function deletes an element d from Domains                         DelTag(t)
set D. If deletion succeeds, the function returns                      end do
the modified D; otherwise, it returns the empty                         E := ¬{e} ∩ E
set. Deletion fails if d is assigned to a data element.                DEnam := E
  DelDomain(d)                                                         x := E
  x := 0                                                          else
  if {d} ∩ D = {d} then                                                display(”entity e can not be deleted”)
       if {t|T dom(t) = d} ∪ {s|Sdom(s) = d} = 0 then             end if
             D := ¬{d} ∩ D                                   else
             DDtype := ¬{d} ∩ DDtype                              display(”entity e not found”)
             DDlng := ¬{d} ∩ DDlng                           end if
             x := D                                          return(x)
             display(”domain d can not be deleted”)         3.4 Tags and Subtags
       end if                                                  3.4.1 Add tag
  else                                                            This function inserts a new tag t in Tags set
       display(”domain d not found”)                        T. Tag t is assigned to an entity e and is given
  end if                                                    a distinct name within the tags of e. A domain
  return(x)                                                 is also selected, but authority status, occurrence
                                                            status and repetition status are simply initialized.
3.3   Entities
                                                            If the insertion succeeds, the function returns the
  3.3.1   Add entity                                        modified T; otherwise, it returns the empty set.
     This function inserts a new element e in En-             AddTag(t, e)
tities set E and assigns a unique message m to                x := 0/
it. If addition succeeds, the function returns the                           /
                                                              if {t} ∩ T = 0 then
modified E; otherwise, it returns the empty set.                     if {e} ∩ E = {e} then
  AddEntity(e)                                                           m := SelectMessage()
  x := 0/                                                                  ¯
                                                                         M := {m|T nam(y) = m, Tent(y) = e}
  if {e} ∩ E = 0 then                                                            /
                                                                         if m = 0 or m ∈ M then
       E := {e} ∪ E                                                            do while z = 0/
       m := SelectMessage()                                                         read(m)
       if m = 0 or m ∈ DEnam−1 then                                                 z := AddMessage(m)
            z := 0 /                                                           end do
            do while z = 0 /                                             end if
                   read(m)                                               T := {t} ∪ T
                   z := AddMessage(m)                                    DTent := T
            end do                                                       Tent(t) := e
       end if                                                            DT nam := {t} ∪ DT nam
       DEnam := E                                                        T nam(t) := m
       Enam(e) := m                                                      d := SelectDomain()
       x := E                                                            DT dom := {t} ∪ DT dom
  else                                                                   T dom(t) := d
       display(”entity e exists”)                                        DTocc := {t} ∪ DTocc
  end if                                                                 Tocc(t) := 0
  return(x)                                                              DTrep := {t} ∪ DTrep
                                                                         Trep(t) := 0
  3.3.2   Delete entity
                                                                         DTaust := {t} ∪ DTaust
    This function deletes an element e from Entities                     Taust(t) := 0
set E. If deletion succeeds, the function returns                        x := T
the modified E; otherwise it returns the empty set.                  else
Deletion fails if there are tags of e that participate in                display(”entity e not found”)
authority links.                                                    end if
 else                                                                  x := t
      display(”tag t exists”)                                     ”create authority link”:
 end if                                                                                  /
                                                                       if {t} ∩ DAuth = 0 then
 return(x)                                                                   tx := SelectTag()
                                                                             do while tx = 0 or Taust(tx ) = 1 or T dom(tx ) = T dom(t)
  3.4.2   Delete subTag
                                                                                  tx := SelectTag()
     This function deletes an element s from Sub-                            end do
tags set S. If deletion succeeds, the function re-                           DAuth := {t} ∪ DAuth
turns the modified S; otherwise it returns the                                Auth(t) := tx
empty set.         If s is the only subtag of the                      else
parent tag t, t is reformed to a simple tag.                                 display(”an authority link already exists”)
  DelSubTag(s)                                                         end if
  x := 0/                                                              x := t
  if {s} ∩ S = 0 then                                             ”delete authority link”:
        if s ∪ {z|Stag(z) = Stag(s)} = s then                          if {t} ∩ DAuth = {t} then
              DT dom := Stag(s) ∪ DT dom                                     DAuth := ¬{t} ∩ DAuth
              d := SelectDomain()                                      else
              T dom(Stag(s)) := d                                            display(”no authority link”)
              DTocc := Stag(s) ∪ DTocc                                 end if
              Tocc(Stag(s)) := 0                                       x := t
        end if                                                         .
        S := ¬{s} ∩ S                                                  .
        DSnam := ¬{s} ∩ DSnam                                          .
        DStag := ¬{s} ∩ DStag                                     end case
        DSdom := ¬{s} ∩ DSdom                                     return(x)
        DSocc := ¬{s} ∩ DSocc
        DSrep := ¬{s} ∩ DSrep
        x := S                                                4     A PRACTICAL EXAMPLE
  else                                                             To illustrate the functionality of the proposed data
        display(”subtag s not found”)                         model, we present an example to demonstrate a data-
  end if                                                      base that manages book and publisher data.
  return(x)                                                        The entity set E contains elements ebook and e publ
  3.4.3   Update tag                                          (Fig. 1a ). In this example, a book is described by
                                                              ISBN, title, author, publisher and year of publication.
     This function updates tag’s properties. It allows        A publisher is described by a publisher ID, corporate
the modification of a tag’s message or a tag’s domain          name, address and phone. The address is a complex
and the conversion of occurrence, repetition and              tag (Fig. 1b ).
authority properties to a different status. It also
enables the manipulation of subtags and authority
links. If an update is effected, function returns the
updated entity t; otherwise, it returns the empty
set. The algorithm presented in this section, it is a
part of the UpdateTag algorithm that illustrates the
manipulation of authority links.
  U pdateTag(t)
  x := 0
  case choice of
  ”change authority status”:                                          Figure 1: a. Function Tent b. Function Stag
       if {q|Tauth(q) = t} = 0 /
             read(aust)                                            A distinct message is assigned to every entity, tag
             do while aust ∈ {0, 1, 2}
                           /                                  and subtag using Enam, T nam and Snam function
                  read(aust)                                  (Fig. 2). Different tags (subtags) can share the same
             end do                                           message as long as they do not reside in the same en-
             Taust(t) := aust                                 tity (tag).
       else                                                        Every message describes a conceptual object that
             display(”authority status can not be changed”)   can be translated into any of the supported languages
       end if                                                 by the Smsg function. In our example, the supported
      Figure 2: Functions Enam, T nam and Snam               Figure 5: a. Functions Tocc, Socc b. Functions Trep,

languages are English and French (Fig. 3).
                                                                  Authority links between tags rely on their domain
                                                             values and their authority status. Linked tags must
                                                             be defined on the same domain. Moreover, authority
                                                             links have to result to a tag with value 1 for author-
                                                             ity status. Value 2 is assigned to tags with contents
                                                             which can be revealed. This assignment is performed
                                                             by Taust action (Fig. 6a ). Function Auth is responsi-
                                                             ble for creating authority links. In our example, there
                                                             is an authority link between t publ and t pbid (Fig. 6b ).

                Figure 3: Function Smsg

    Simple tags and subtags hold data which is de-
rived from specific domains. Matching is performed
by the functions T dom and Sdom (Fig.4). The com-
plex tag taddr has no domain assigned to it because its
subtags are based on specified domains.
                                                                  Figure 6: a. Function Taust b. Function Auth

                                                             5   CONCLUSIONS            AND      FURTHER          RE-
                                                                  The design of data models that evolve with time
                                                             is still a major problem today. While user require-
                                                             ments change quite frequently, databases continue to
                                                             show little flexibility in supporting these changes in
                                                             their structures and data organization. Research car-
                                                             ried out in the direction of supporting schema evolu-
                                                             tion and schema versioning has proved inefficient in
          Figure 4: Functions T dom and Sdom                 the long-term. In this paper we proposed an integrated
                                                             set-theoretic model for database systems that forms a
    Every simple tag and every subtag has an occur-          framework for defining a structure (unified schema)
rence status, which is mandatory (value 1) or optional       that eliminates completely the need for reorganiza-
(value 0). Assignment is performed by the functions          tion at the logical level. We presented its structure,
Tocc and Socc. The complex tag taddr has no occur-           its features and we demonstrated some of its opera-
rence status as it has no domain (Fig. 5a ). On the          tions with algorithms that can be applied at the log-
other hand, repetition status is required for all tags and   ical level (metadata). The next step is to investigate
subtags. Value 1 is given to repeating tags. In our ex-      efficient data storage, data retrieval and manipulation
ample, the repeating tags are t phon and tauth (Fig. 5b ).   operations, as well as data integrity rules and perfor-
                                                             mance issues.
 [1] D. Sjoberg: Quantifying Schema Evolution, In-
     formation and Software Technology, 35(1), pp.
     35-44 (1993).
 [2] J. F. Roddick: A Survey of Schema Version-
     ing Issues for Database Systems, Information
     and Software Technology, 37(7), pp. 383-393
 [3] J. F. Roddick: A model for schema versioning
     in temporal database systems, Australian Com-
     puter Science Communications, 18(1), pp. 446-
     452 (1996).
 [4] C. De Castro, F. Grandi , M. R. Scalas: Schema
     versioning for multitemporal relational data-
     bases, Information Systems, 22(5), pp. 249-290
 [5] F. Grandi , F. Mandreoli , M. R. Scalas: A Gen-
     eralized Modeling Framework for Schema Ver-
     sioning Support, In Proc. ADC 2000, pp. 33-40
 [6] E. Franconi , F. Grandi , F. Mandreoli: Schema
     Evolution and Versioning: a Logical and Com-
     putational Characterisation, In Proc. DEMM
     2000, pp. 67-81 (2000).
 [7] W. Kim, H. T. Chou: Versions of Schema for
     Object-Oriented Databases, In Proc. of 14th
     VLDB Conf., pp. 148-159 (1988).
 [8] S. Monk, I. Sommerville: Schema Evolution in
     OODBs using Class Versioning, SIGMOD Rec.,
     22(3), pp. 16-22 (1993).
 [9] S. E. Lautemann: Schema Versions in Object-
     Oriented Database Systems, In Proc. DASFAA,
     pp. 323-332 (1997).
[10] X. Li, Z. Tari: Class Versioning for the Schema
     Evolution, Australian Computer Science Com-
     munications, 20(2), pp. 117-128 (1998).
[11] E. J. Yannakoudakis, C. X. Tsionos, C. A.
     Kapetis: A new Framework for dynamically
     evolving Database Environments, Journal Of
     Documentation, 55(2), pp. 144-158 (1999).
[12] E. J. Yannakoudakis, I. K. Diamantis: Further
     improvements of the Framework for Dynami-
     cally Evolving Database Environments, In Proc.
     HERCMA 2001, pp. 213-218 (2001).
[13] F. Grandi: A Relational Multi-Schema Data
     Model and Query Language for full Support of
     Schema Versioning, In Proc. SEBD 2002, pp.
     323-336 (2002).
[14] R. Johnsonbaugh: Discrete mathematics, 6th
     edition, Pearson Education, London, (2005).

To top