1. Jesús Sánchez Cuadrado
Grupo modelum
http://www.modelum.es
Universidad de Murcia
Lenguajes de Transformación de Modelos
Eclipse Day
2 de Diciembre de 2008, Valencia

2. Transformación de modelos
Manipulación de un modelo
Ejemplos
Relaciones entre lenguajes
Sincronización de vistas en Eclipse
Lenguaje de alto nivel a artefactos de bajo nivel
Desarrollo basado en DSLs
Refactorizar modelos
Introducir superclase
Ingeniería inversa
Descubrir relaciones entre módulos
Manipulación en general de un modelo
El código fuente también es un modelo!
Utilizamos lenguajes de transformación de modelos
2/12/08 Jesús Sánchez Cuadrado 2

3. Transformación de modelos
Lenguaje
MMorigen Transformación MMdestino
<<conforma>> <<conforma>> <<conforma>>
Morigen Mdestino
transforma genera
Definición de
transformación
2/12/08 Jesús Sánchez Cuadrado 3

4. Transformación de modelos
Metamodelo
Classifier Simple UML
type
PrimitiveDataType name: String
1
Package * Class *
Attribute
name: String elems isPersistent: Bool attrs
Mapping
Table 0..1 1
Schema * Column
name: String tbls name: String pkey
name: String
cols type: String
refs *
FKey Metamodelo
Simple RDBMS
2/12/08 Jesús Sánchez Cuadrado 4

5. Lenguajes de transformación
Restricciones
self.license = #FreeSoftware and
self.metamodel->include('Ecore')
Selección
Set { Java/EMF, ATL, QVTr, QVTo,
Tefkat, Epsilon, Viatra,
RubyTL }
2/12/08 Jesús Sánchez Cuadrado 5

6. Características
Tipo = { Imperativo, Declarativo, Híbrido }
Usabilidad
Entorno, instalación, etc.
Tipado
Manejo de errores
Bidireccional o unidireccional
Mecanismos de modularidad
Grano fino
Grano grueso
Consistencia incremental
Eficiencia
Compilación incremental
2/12/08 Jesús Sánchez Cuadrado 6

7. EMF + Java
Usar Java para manipular modelos Ecore
Aproximación de manipulación directa
Imperativo
El modelo se manipula con sentencias Java
Se puede crear un pequeño framework de soporte
Unidireccional
Usabilidad
Funciona. Eficiente.
Detalles de bajo nivel. Verboso.
Mecanismos de modularidad
Herencia, composición
2/12/08 Jesús Sánchez Cuadrado 7

8. EMF + Java
protected void rulePackage2Schema() { Recorrer
for( EObject pkg : allObjectsOf(IN, quot;Packagequot;) ) {
EObject newSchema = createObject(OUT, quot;Schemaquot;);
addToResource(OUT, newSchema); Crear
ruleClass2Table(pkg, newSchema); Invocar
}
}
protected void ruleClass2Table(EObject pkg, EObject schema) {
List<EStructuralFeature> classifiers = getMulFeature(pkg, quot;classifiersquot;);
List<EStructuralFeature> tables = getMulFeature(pkg, quot;tablesquot;);
for( EObject classifier : classifiers ) {
EObject newTable = createObject(OUT, quot;Tablequot;);
if ( isKindOf(classifier, quot;Classquot;) ) {
setFeature(newTable, quot;namequot;, getFeature(classifier, quot;namequot;));
tables.add(newTable);
...
}
}
}
Framework de soporte
2/12/08 Jesús Sánchez Cuadrado 8

9. EMF + Java (Valoración)
:-) Siempre funciona
:-) Modularidad, reutilización, compilación...
:-( Muy verboso
:-(
Falta de mecanismos de registro de trazas, evitar
ciclos, consultas de modelos, etc.
2/12/08 Jesús Sánchez Cuadrado 9

10. ATL
Atlas Transformation Language
Lenguaje oficial del proyecto Eclipse M2M
http://www.eclipse.org/m2m/atl/
Híbrido
Parte declarativa. Reglas y bindings.
Parte imperativa. Poco desarrollada.
Unidireccional. No incremental.
Modularidad: reglas abstractas, superimposición
Plugin para Eclipse
Editor
Depurador : objeto.debug('salida:')
2/12/08 Jesús Sánchez Cuadrado 10

11. ATL
Origen
rule Class2Table { Destino
from c : Class!Class
to out : Relational!Table (
name <- c.name, Binding
cols <- Sequence {key}->union(c.attributes),
key <- Set {key} Recorrido implícito
),
key : Relational!Column (
name <- 'id',
type <- Class!DataType.allInstances()->any(e | e.name = 'Integer')
)
}
rule DataTypeAttribute2Column { OCL
from a : Class!Attribute (
a.type.oclIsKindOf(Class!DataType)
) Filtro
to out : Relational!Column (
name <- a.name,
type <- a.type
)
}
2/12/08 Jesús Sánchez Cuadrado 11

12. ATL (Valoración)
:-) Es el estándar de facto por su simplicidad.
:-) Bastante documentación.
:-(
Necesidad de muchas consultas con OCL Tuple
cuando la complejidad crece un poco.
:-( Mal reporte de errores
2/12/08 Jesús Sánchez Cuadrado 12

13. QVT Relational
Query Views Transformations (OMG)
Estándar OMG
Declarativo. Bidireccional.
Relaciones entre los metamodelos. Patrones.
Sintaxis gráfica de QVT.
Usabilidad – depende de la implementación
Tipado estático. ¿Es suficiente el estándar como guía?
Ningún mecanismo de modularidad.
Implementaciones
MediniQVT. Implementación IKV++
http://projects.ikv.de/qvt
Consistencia y compilación incremental
2/12/08 Jesús Sánchez Cuadrado 13

14. QVT Relational
Variable
top relation PackageToSchema {
pn : String;
checkonly domain uml p : UML::Package { Patrón
name = pn
};
enforce domain rdbms s : Relational::Schema {
name = pn
};
}
Var. ligada
Una relación : declaraciones de dominio.
Un dominio : establece un patrón.
En la ejecución las relaciones se comprueba, y si
es necesario se fuerzan.
La clave está en ligar variables.
2/12/08 Jesús Sánchez Cuadrado 14

15. QVT Relational
relation ClassToTable {
cn : String;
prefix : String;
checkonly domain uml c : UML::Class {
package = p : UML::Package { }, Navegación
name = cn
}; implícita
enforce domain rdbms t : Relational::Table {
schema = s : Relational::Schema { },
name = cn,
columns = cl : Relational::Column {
name = 'id',
type = 'NUMBER'
},
key = k : Relational::Key {
column = cl : Relational::Column { }
}
};
when { “matching” Precondición
PackageToSchema(p, s);
}
where { “una llamada” Postcondición
ClassToPkey(c, k);
prefix = cn;
AttributeToColumn(c, t, prefix); Parámetro
}
}
2/12/08 Jesús Sánchez Cuadrado 15

16. QVT Relacional - Valoración
:-) Paso de parámetros en where
:-) Clausulas en when son consultas de la traza
:-(
Abuso del opposite en los patrones, típicamente
con variables del when
:-( ¿Es esto declarativo?
relation AttributeToColumn {
checkonly domain uml c : UML::Class { };
Son parámetros... enforce domain rdbms t : Relational::Table { };
primitive domain prefix : String;
where {
ComplexAttributeToColumn(c, t, prefix);
¿Cuál se ejecuta? PrimitiveAttributeToColumn(c, t, prefix);
SuperAttributeToColumn(c, t, prefix);
}}
2/12/08 Jesús Sánchez Cuadrado 16

17. Tefkat
The Engine Formerly Known As Tarzan
DSTC submission for QVT RFP
http://tefkat.sourceforge.net/
Declarativo, basado en
Reglas
Patrones (al contrario que QVT, están separados)
Una transformación satisface las restricciones para
crear un modelo destino
Modelo origen: se puede leer
Modelo destino: se establecen restricciones
Tracking extent: se puede leer, se pueden establecer
restricciones.
Tracking classes permiten establecer relaciones
nombradas entre el origen y el destino
2/12/08 Jesús Sánchez Cuadrado 17

18. Tefkat
CLASS ClsToTbl {
Class class;
Table table; “traza explícita” Tracking
}; classes
CLASS AttrToCol {
Class class;
Attribute attr;
Column col;
};
RULE ClassAndTable(C, T)
FORALL Class C { name: Name; } Crear traza
MAKE Table T { name: Name; }
LINKING ClsToTbl WITH class = C, table = T;
Restricción
RULE MakeColumns sobre patrón
WHERE ClassHasAttr(Class, Attr, Name, IsKey)
AND ClsToTbl LINKS class = Class, table = Table Restricción
MAKE Column Col FROM col(C, N) { sobre traza
name: Name;
type: Attr.type.name;
}
SET Table.cols = Col,
IF IsKey = true
THEN
SET Table.pkey = Col
ENDIF
LINKING AttrToCol WITH class = C, attr = A, col = Col;
2/12/08 Jesús Sánchez Cuadrado 18

19. Tefkat
PATTERN ClassHasAttr(Class, Attr, Name, IsKey)
WHERE ClassHasSimpleAttr(Class, Attr, Name, IsKey) Patrón
OR ClassHasIncludedAttr(Class, Attr, Name, IsKey)
OR ClassChildHasAttr(Class, Attr, Name, IsKey)
;
PATTERN ClassHasSimpleAttr(Class, Attr, Name, IsKey)
FORALL Class Class {
attrs: Attribute Attr {
type: PrimitiveDataType _PT;
name: Name;
};
}
WHERE IsKey = Attr.is_primary;
2/12/08 Jesús Sánchez Cuadrado 19

20. Tefkat
:-) Tracking classes
:-) Patrones separados de reglas
:-( Muy poco eficiente
:-( Dificil hacerlo funcionar
2/12/08 Jesús Sánchez Cuadrado 20

21. QVT Operacional
Query Views Transformations (OMG)
Estándar OMG
Imperativo. Unidireccional.
Llamadas explícitas a reglas.
Manipulación de la traza: resolve
Usabilidad – depende de la implementación
Tipado estático. ¿Es suficiente el estandar como guía?
Mecanismo de modularidad a nivel de regla.
Implementaciones
SmartQVT.
Proyecto Eclipse M2M.
Open Canarias
2/12/08 Jesús Sánchez Cuadrado 21

22. QVT Operacional
main() { Punto de
uml.objectsOfType(Package)->map packageToSchema();
} entrada
mapping Package::packageToSchema() : Schema
when { self.name.startingWith <> “_” } Filtro
{
name := self.name;
table := self.classifiers->map class2table();
} Llamada a
mapping Class::class2table() : Table regla
{
name := self.name;
columns := self.attributes->map attr2col();
}
2/12/08 Jesús Sánchez Cuadrado 22

23. QVT Operacional
:-) Intuitivo en principio
:-) Potente para abordar transformaciones complejas
:-( Muchas maneras de hacer lo mismo
:-( No encuentro implementaciones que funcionen
2/12/08 Jesús Sánchez Cuadrado 23

24. Epsilon y Viatra
Epsilon
Framework de lenguajes
http://www.eclipse.org/gmt/epsilon/
Interacción con el usuario (integración con GMF)
Utilidad: pequeñas refactorizaciones, scripting
Viatra
Basado en grafos
http://www.eclipse.org/gmt/VIATRA2/
2/12/08 Jesús Sánchez Cuadrado 24

25. RubyTL
RubyTL
Universidad de Murcia :-)
http://gts.inf.um.es/age
DSL embebido en Ruby
Reutilizamos la infraestructura de Ruby
Híbrido
Parte declarativa. Reglas y bindings.
Parte imperativa. Muy potente. Ej. .map, cadenas, etc.
Concepto novedoso: phases
Usabilidad
Acompañado de otros DSLs
Validación, generación de código, creación de sintaxis
concreta, etc.
2/12/08 Jesús Sánchez Cuadrado 25

26. RubyTL
phase 'class2table' do Fase
top_rule 'class2table' do
from ClassM::Class Binding
to TableM::Table
mapping do |class, table|
table.name = class.name
table.cols = class.attrs
end
end
rule 'property2column' do
from ClassM::Attribute
to TableM::Column
filter { |attr| attr.type.is_a? ClassM::PrimitiveType }
mapping do |attr, column|
column.name = attr.name
column.type = attr.type.name
if attr.is_primary
column.owner.pkeys << TableM::PKey.new(:col => column)
end
end
end
end Código Ruby
2/12/08 Jesús Sánchez Cuadrado 26

27. RubyTL
import 'm2m://class2table', :as => 'class2table' Importar
phase 'fkeys' do
top_rule 'attribute2fkey' do
from ClassM::Attribute
to TableM::FKey
filter { |attribute| attribute.reference? }
mapping do |attribute, fkey|
fkey.owner = trace_query(attribute.owner).one(TableM::Table)
fkey.references = trace_query(attribute.type).one(TableM::Table)
fkey.cols = trace_query(attribute).all(TableM::Column)
end
end
end
Consultar
la traza
scheduling do
execute 'class2table'
execute 'fkeys'
end
Constructos: refinement_rule y trace_query
Resolver dependencias “dificiles”
Composición de transformaciones independientes
2/12/08 Jesús Sánchez Cuadrado 27

28. RubyTL
:-) Muy potente. Usable.
:-) Mecanismo de modularidad. Phases.
:-( No escala bien con modelos grandes.
:-( Hay que instalar Ruby.
2/12/08 Jesús Sánchez Cuadrado 28

29. Modularidad
superimposition vs. phases
Sobreescribir
reglas
No permite
herencia de
reglas
T1 T2 T3 Transformaciones
independientes
<<import>> “Comunicación”
a través de la
Tm traza
2/12/08 Jesús Sánchez Cuadrado 29

30. Valoración personal
Faltan implementaciones realmente estables
± estables : ATL, RubyTL, Epsilon
Reutilización muy limitada
Superimposición y phases
Buenas ideas como tracking classes poco
desarrolladas
¿Es QVT el lenguaje definitivo?
¿Ha sido QVT perjudicial para la investigación?
2/12/08 Jesús Sánchez Cuadrado 30