Retainment Rules for Model Transformations
Thomas Goldschmidt1, Axel Uhl2
1 FZI Research Center for Information Technology, Karlsruhe, Germany,
goldschmidt@fzi.de
2 SAP AG, Walldorf, Germany, axel.uhl@sap.com
Abstract. Model-to-model (M2M) transformations play an important role within
model-driven development. Modern M2M approaches also support incremental
updates to the target model(s) which are executed according to changes in the
source model(s) to keep the target model(s) in sync. However, in some cases,
e.g., if the target model is going to be refined either manually or automatically
it is important that those changes are not overwritten if the original transforma-
tion is re-executed. There is currently weak support for this kind of retainment
by transformation engines. This paper proposes transformation annotations for
Retainment Policies which determine the transformation behaviour in subsequent
executions of the transformation with respect to manual changes in the target
model(s).
1 Introduction
Transformations are an important aspect of model-driven development. Transforma-
tions that take models as input and transform it into another model are called model-
to-model (M2M) transformations. M2M transformations specify rules against a source
metamodel and a target metamodel. Applying this transformation on an instance of the
source metamodel will create or update an instance of the target metamodel according
to the specified rules.
The capability of incrementally transforming models is one of the key features of
modern transformation engines [1]. This allows for keeping most parts of the target
model1 as is when only a small, local change was made in the source model and the tar-
get model gets updated through the transformation. However, in some use-cases (man-
ual refinement or definition of views [2]) it becomes necessary that also the target model
can be changed manually. When the transformation that once created the target model
gets re-executed usually all manual changes will be lost and the target model will be
re-synced according to the transformation rules. In currently existing work this problem
can only be solved by manually changing the transformation. No general solution for
the retainment of all kinds of modifications exists.
This paper introduces an approach for specifying policies for the handling of manual
changes. These policies can be attached to M2M transformation rules and define how
1The presented approach is not restricted to having only a single source and/or target model.
However, for sake of simplicity we only talk about one source/target model here.

the transformation rules should deal with manual changes in the target model when the
transformation is re-executed.
The presented approach focuses on declarative transformation specifications, such
as the Query, View, Transformation (QVT) relations language [3] or ATL [4]. However,
it may also be possible to adopt the presented approach to other, for example, imperative
languages.
The contribution of this paper consists of (a) the classification of changes that may
occur on a generic model level, such as addition or deletion of an element within a
model reference. (b) Based on this classification, policies are derived that make it pos-
sible to specify possible retainment actions, for every possible change. (c) Furthermore,
an implementation of the specified policies is provided for the QVT relations language.
This paper is structured as follows. Section 2 discusses which kind of retainment
handling was presented in existing work. A classification of model changes that have
to be considered is presented in Section 3. The different policies that can be defined
for retainment of these changes is introduced in Section 4. In Section 5 we present a
prototypical implementation on how these policies can be translated into standard QVT-
R rules. Finally, Section 6 highlights research issues concerning our approach that have
not yet been solved and Section 7 concludes.
2 Related Work
The OMG’s model tranformation standard Query, View, Transformation (QVT) [3],
does only provide two different ways of executing a transformation rule: The checkonly
property means that the rule only checks if the specified pattern matches constructs in
the model. For applying changes to a model the enforce property may be set. To be
able to handle retainment of manual changes it is necessary to manually implement ad-
ditional rules or manually adapt existing transformation rules. In section 5 we present
how generic retainment policies can be automatically mapped to standard QVT-R con-
structs.
The Eclipse Graphical Modelling Framework (GMF) [5] allows users to specify
graphical syntaxes for models for using model driven techniques. As it is also possible
to modify intermediate models in the transformation chain, GMF offers the possibility
to specify that once an element has been changed manually this change should not
be overwritten by further re-transformations. However, this is a manual implemented
retainment rule and no general approach is provided to solve this problem.
Tratt [6] presents an approach for change propagation in model transformations that
allows users to make arbitrary changes to the source as well as the target model and then
re-run the transformation non-destructively. However, no complete set of configuration
possibilities for retainment policies is available there. I.e., it is not possible to explicitly
specify for the transformation rules how they should behave.
Paige et al. [7] present an approach on how consistency rules can be defined between
source models and their refinable target models. This way it is possible to detect were
a refinement is inconsistent with the transformation and the target model. However, in