Model Transformations

Marcos AurélioDecember, 2007

Extends:

Fabrício Teles, Rodrigo Teixeira

@ 2006-1

Outline

• What is a model transformation?• Purposes in MDD• Taxonomy• Techniques• Comparison

What is a model transformation?

• Transformations takes models and produces models– PIM to PSM (OMG MDA)– Refining and refactoring models– Reverse engineering – Generating new views– Applying design patterns – Deriving products in a product line

Typical example (UML to RDMS)

Desirable properties of a Model Transformation Language

• be executable;• be implementable in an efficient way;• be fully expressive, yet unambiguous.• facilitate developer productivity with precise, concise and

clear descriptions:– source model selection rules rules for producing the target model;– the language should offer graphical constructs – the language should be declarative – Tools for development and testing

• provide a means to combine transformations to form composite ones [reuse]

• provide a means to define scheduling • is defined upon a Metamodel• has a formal semantics

Model transformations techniques

• General purpose programming languages (Java, FLORA)

• Generic transformation tools (XSLT)

• Case tools scripting languages (Rose)

• Dedicated model transformations tools (QVT, ATL)

General purpose programming languages

General purpose programming languages

• Available via APIs, – however rules are implemented from scratch

• There’s no clear concept of “rule”

– Example: JMI (MOF-compliant Java Interface)

– No overhead to learn a new language– The programming complexity problem

continues

JMI

Java Modeling Interface

Motivation• “Exchange of data” problem

–There is no standard between models

–Data extraction tools are not flexible enough

• Solution: –Use a standard to define metadata

Introduction

• Implements MOF specification in Java– Allows Java applications to specify, store,

access and interchange metadata.– Provides an integration and interoperability

framework for Java tools and applications– Integrates with OMG modeling and metadata

architecture

• Part of the J2EE platform

Example – Simple XML metamodel

Example –Generated Java Classes

Element---------------------------------------

+ getName() : String+ setName(s: String)

+ getContainer() : Node+ setContainer(n:Node)

AttributeClass-------------------------------------------+createAttribute() : Attribute

+ createAttribute(name:String,value: String)

ElementClass

Contains---------------------------------------+ exists(e:Element, c:Node) : Boolean+ getElements(c:Node):Element[*]+ getContainer(e:Element):Node+ add(e:Element, n:Node) : Boolean+ remove(e:Element, n:Node) : Boolean

XMLModelPackage--------------------------------------------------+ getNode() : NodeClass+ getAttribute() : AttributeClass+ getElement() : ElementClass+ getRootNode() : RootNodeClass+ getContains() : Contains

Example – Code

<test><node attr1="value1" attr2 ="value2">text</node></test>

Example – CodeRootNode root = service.getRootNode().createRootNode(<name>,

<documentName>);// create the root nodeRootNode root = service.getRootNode().createRootNode("test","test.xml");// create the first nodeNode node = service.getNode().createNode("node");// set root as its containernode.setContainer(root);// now create the two attributesAttribute attr1 = service.getAttribute().createAttribute("attr1","value1");Attribute attr2 = service.getAttribute().createAttribute("attr2","value2");

Example – Code

// (this is an alternative way of setting the container)

node.getElements().add(attr1);

node.getElements().add(attr2);

// create the text node

TextNode text = service.getTextNode().createTextNode("text");

// set node as its container

text.setContainer(node);

Flora

Flora (F-Logic)

• Frame Logic is an object oriented deductive database language

• Syntactical integration between Object Oriented Paradigm and Rules

• Combines expressivity and declarative semantics to object oriented concepts.

• Implements Structural and Behavioural Inheritance with support for Single-source Multiple Inheritance

• Flora is an implementation for F-logic over XSB Prolog

Flora - MetaModel

criminal(X) :- american(X), sellsWeaponsTo(X,cuba).american(X) :- bornIn(X,usa).bornIn(west, usa).

Program

Example:

Flora - MetaModel

criminal(X) :- american(X), sellsWeaponsTo(X,cuba).american(X) :- bornIn(X,usa).bornIn(west, usa).

ClauseExample:

Flora - MetaModel

criminal(X) :- american(X), sellsWeaponsTo(X,cuba).american(X) :- bornIn(X,usa).bornIn(west, usa).

LogicalPredicativeAtomExample:

Flora - MetaModel

criminal(X) :- american(X), sellsWeaponsTo(X,cuba).american(X) :- bornIn(X,usa).bornIn(west, usa).

QueryExample:

Flora - MetaModel

criminal(X) :- american(X), sellsWeaponsTo(X,cuba).american(X) :- bornIn(X,usa).bornIn(west, usa).

OperatorExample:

F-Atoms

• Class Hierarchy–cachorro :: mamifero, jacare :: reptil –mamifero :: animal, reptil :: animal

• Class Instances–cao1 : cachorro, jacare1 : jacare

• Attributes and Methods definition–cao1[qtdPatas -> 4], joao[salario(2005)->1200]

–cachorro[qtdPatas *-> 4], empregado[salario(2005)*->1200]

Book To Publication Example

Flora

• Example:

book[title => string, chapters =>> chapter[nbPages => integer,

title => string,

author => string]].

publication[title => string,

nbPages => integer,

authors =>> string].

P:publication[title -> T, nbPages -> N, authors -> As] :-

B:book[title -> T, chapters ->> C],

N = sum{M|C[nbPages -> M]},

As = collectset{A|C[author -> A]}.

F-logic file

XSLT

eXtensible Stylesheet Language Transformation

eXtensible Stylesheet Language Transformation (XSLT)

• XML-based language used for the transformation of XML documents

• Part of a W3C family of languages (XSL)– Describes how to format

and transform XML files– XSLT, XSL-FO, XPath

• Used to model transformation– Where models are in XMI

encoding format

eXtensible Stylesheet Language Transformation (XSLT)

• XSLT Characteristics– Declarative rather than imperative– Consist of a template rules collection– Each rule specifies what to add to a target fragment

• Based on a source fragment and a fixed algorithm

– XSLT processor scan the source tree, apply rules and generate de target tree

– Syntactical & ineffic for model transformations• XML (XMI) is verbose• Operates on tree structures• More batch than interactive• Parameters passed by value

eXtensible Stylesheet Language Transformation (XSLT)

XMLDocument 1

XMLSDocument 1

Valid

XSLTDocument

XSLTEngine

SourceSchema

FragmentMatchingPatterns

XMLDocument 2

XMLSDocument 2

Valid

TargetSchema

FragmentInsertion Actions

MatchedSource Fragments

• Transformation process:

– Source document matching patterns

– XSLT document specifying actions that copy matched elements and attributes from source document and assemble them in a novel way

– Target document matching transformations

eXtensible Stylesheet Language Transformation (XSLT)

• Example:

<model xmlns:uml="http://www.eclipse.org/uml2/1.0.0/UML" xmlns:xmi="http://www.omg.org/XMI">

<package id="pck1" name=“library">

<class id="c1" name="Book">

<association aggregationType="composite" id="c1_ass1" name="chapters" targetClass="c2"/>

<attribute cardinality="1..1" id="c1_atr1" name="title" type="dt1"/>

</class>

<class id="c2" name="Chapter">

<attribute cardinality="1..1" id="c2_atr1" name="nbPages" type="dt2"/>

<attribute cardinality="1..1" id="c2_atr2" name="title" type="dt2"/>

<attribute cardinality="1..1" id="c2_atr3" name="author" type="dt1"/>

<association aggregationType="none" id="c2_ass1" name="book"

targetClass="c1"/>

</class>

</package>

</model>

Source file: book.xmi

eXtensible Stylesheet Language Transformation (XSLT)

• Example:

<?xml version="1.0" encoding="UTF-8"?>

<xsl:transform version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >

<xsl:output method="xml" />

<xsl:template match="library.Book" >

<xsl:variable name="title" select="@title" />

<xsl:variable name="authors" select="concat(@chapters.author, ',')"/>

<xsl:variable name="nbPages" select="sum(@chapters.nbPages)"/>

<xsl:call-template name="createPublication">

<xsl:with-param name="title" select="$title"/>

<xsl:with-param name="authors" select="$authors"/>

< xsl:with-param name="nbPages" select="$nbPages"/>

</xsl:call-template>

</xsl:template>

</xsl:transform>

XSLT file: book2Publicartion.xslt fragment

eXtensible Stylesheet Language Transformation (XSLT)

• Example:

<model xmlns:uml="http://www.eclipse.org/uml2/1.0.0/UML" xmlns:xmi="http://www.omg.org/XMI">

<package id="pck1" name=“library">

<class id="c1" name="Publication">

<attribute cardinality="1..1" id="c1_atr1" name="title" type="dt1"/>

<attribute cardinality="1..1" id="c1_atr2" name="nbPages" type="dt2"/>

<attribute cardinality="1..1" id="c1_atr3" name="authors" type="dt1"/>

</class>

<datatype id="dt1" name="String"/>

<datatype id="dt2" name="Integer"/>

</package>

</model>

Target file: publication.xmi

Case tools scripting languages

CASE tool scripting language

• Ex.: Rose, OptimalJ, Arcstyler, Fujaba• Pro

– Good level of maturity– Excellent integration with their CASE tool

• Drawback– Proprietary language – Often developed as a “second-class” feature, non

central role– Many limitations when model transformations get

complex • Structuration, modularity, reuse and configuration management

problems

QVT

Query View Transformation

Query-View-Transformation (QVT)

• OMG standard language for expressing queries, views, and transformations on MOF models

• DSL for transformation aimed for– Simple development and maintenance of

model transformations– With high expressiveness– And enhanced structuring capabilities

• Composition of rules and Interoperability

OCL-based hybrid procedural and declarative transformation language

QVT [hybrid] Architecture

DeclarativeImperative

Overview of the Architecture

• Declarative Relations transformation language– Specification of relations over model elements

• Declarative Core transformation language– Simple transformation language– Reference point for defining the semantics of the

Relations language

• Operational Mappings– Imperative transformation language– Extends Relations language with imperative constructs

Model Transformation expressed inOperational Mappings Language

Overall structure of a transformation program:

metamodel 'http://www.borland.com/together/uml20';

transformation BookToPublication (in InputMetamodel): OutputMetamodel

…………………………………………………………………

main () {…………………………………………………………………

}

…………………………………………………………………

…helpers……………………………………………

…mapping operations………………

…………………………………………………

Signature:Declares the identifier of the transformation

Entry point:The execution of the transformation starts here by executing the operations in the body of main.It also declares the source and target metamodels. in keywords indicate source and target model variables. The target is represented by the return of main.

Transformation elements:Transformation consists of mapping operations and helpers. They form the transformation logic.

BookToPublication Example in the OMG QVT Specification [05-11-01.pdf]

metamodel BOOK { class Book {title: String; composite chapters: Chapter;} class Chapter {title : String; nbPages : Integer;} }metamodel PUB { class Publication {title : String; nbPages : Integer;} }

transformation Book2Publication(in bookModel:BOOK,out pubModel:PUB)

main() { bookModel->objectOfType(Book)->map book_to_publication(); }mapping Class::book_to_publication () : Publication { title := self.title; nbPages := self.chapters->nbPages->sum();}

Book To Publication considering the UML 2.0 metamodel

Publication

Attributes+title:String+authors:String+nbPages:Integer

Library

Operations+get

PublicationMyBook:PublicationSlots

title=Eng. Softwareauthors=Rodrigo and FabricionbPages=25

1

1

has

<<instantiate>>

Book

Attributes+title:String

Chapter

Attributes+nbPages:Integer+title:String+authors:String

Library

Operations+get:Book

Cha2:ChapterSlots

nbPages=15title="Implementacao"authors=Fabricio

Cha1:ChapterSlots

nbPages=10title="Modelagem"authors=Rodrigo

MyBook:BookSlots

title=Eng. Software

chapters

has

<<instantiate>>

<<instantiate>>

<<instantiate>>

BookToPublication - Together (imperative QVT implementation)

mapping main(in model: uml::together::Model): ... Model { ownedMembers += replaceClasses (model); ownedMembers += replaceInstances (model); }

query getClasses (in root: ...Model): OrderedSet(...Class){ root.ownedMembers->...collect(c | class2class(c.oclAsType(...Class)))-> asOrderedSet();

}

query publicationClass () : ...Class

object uml20::classes::Class {

name := 'Publication';

ownedAttributes += object uml20::kernel::Property { name := 'title'; type := string};

...

BookToPublication – Together (cont.)

mapping publicationInstance (in bookInstance: InstanceSpecification) :...when { bookInst.instantiates->...exists(c | c.name = 'Book')} var publicationClass := bookInst.instantiates->select( ... 'Publication‘...

name := 'Publication'+bookInst.name; instantiates += bookInst.instantiates->resolve(‘class2class’).... slots += object uml20::kernel::instances::Slot { definingFeature := publicationClass >select...-> any(... | feature.name = 'authors');

values += select (bookInst.dependencies ... -> select( ... 'chapters')->

....select( ...definingFeature.name = 'authors')-> .... iterate(authorName; acc : String = ‘ ' | acc + (if acc = ‘ ' then authorName else ' and ' + authorName endif)); ...

ATL

Atlas Transformation Language

ATL

• Source models and target models are distinct:– Source models are read-only (they can only be

navigated, not modified),– Target models are write-only (they cannot be navigated).

• The language is a declarative-imperative hybrid:– Declarative part:

• Matched rules with automatic traceability support,• Side-effect free navigation (and query) language: OCL 2.0

– Imperative part:• Called rules,• Action blocks.

• Recommended programming style: declarative

ATL x QVT

• ATL and QVT have common features but their problem domains are different:– QVT is mainly for software development;– ATL aims at solving data engineering transformation problems

• Major ATL requirement: ability to deal with various models expressed in different languages and technologies

• Architectural alignment between ATL and QVT shows that language interoperability is feasible via model transformations

• ATL tools may be called QVT conformant

Comparing the Languages

Comparation TableJava FLORA XSLT Case Tools QVT ATL

Concise X X Xwell-know languages

X X

Executable X X X X ? XExpressive X X X XMetamodel X X X X XFormal semantics X Standards X X XAll OO/MOF concepts

X X X X

Tools X X X X X X

Conclusions

• Model Transformations are assets– guided by sound Soft. Engineering principles

• Analysis, Design, Implementation, V & V (Test), and Configuration Management (evolution)

• Transformations should also be models (principles of MDE)– In order to tackle complexity

Links and Papers

• JSR-040• http://modelware.inria.fr• http://www.modelware-ist.org (Main Repository Page \ Training)• http://www.eclipse.org/gmt/atl• http://wwwcs.uni-paderborn.de/cs/kindler/Forschung/

ComponentTools/ct-seminar/Java%20Metadata%20Interface%20-%20Ausarbeitung.pdf

• Czarnecki and Helsen: Classification of Model Transformation Approaches.

• Shane Sendall and Wojtek Kozaczynski: Model Transformation – the Heart and Soul of Model-Driven Software Development

• Anna Gerber at al: Transformation: The Missing Link of MDA