Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.
Jesús Sánchez Cuadrado
Grupo modelum
http://www.modelum.es
Universidad de Murcia




        Lenguajes de Transformación d...
Transformación de modelos
  Manipulación de un modelo
  Ejemplos
          Relaciones entre lenguajes
             Sincron...
Transformación de modelos



                               Lenguaje
          MMorigen          Transformación           ...
Transformación de modelos
                                                                                      Metamodelo...
Lenguajes de transformación
  Restricciones

          self.license   = #FreeSoftware and
          self.metamodel->includ...
Características
  Tipo = { Imperativo, Declarativo, Híbrido }
  Usabilidad
          Entorno, instalación, etc.
          ...
EMF + Java
  Usar Java para manipular modelos Ecore
          Aproximación de manipulación directa
  Imperativo
          ...
EMF + Java

protected void rulePackage2Schema() {                            Recorrer
  for( EObject pkg : allObjectsOf(IN...
EMF + Java (Valoración)

  :-)     Siempre funciona

  :-)     Modularidad, reutilización, compilación...


  :-(     Muy ...
ATL
  Atlas Transformation Language
          Lenguaje oficial del proyecto Eclipse M2M
          http://www.eclipse.org/m...
ATL

                                                             Origen

rule Class2Table {                              ...
ATL (Valoración)

  :-)     Es el estándar de facto por su simplicidad.

  :-)     Bastante documentación.


  :-(
       ...
QVT Relational
  Query Views Transformations (OMG)
          Estándar OMG
  Declarativo. Bidireccional.
          Relacion...
QVT Relational
                                                    Variable
top relation PackageToSchema {

    pn : Strin...
QVT Relational
relation ClassToTable {
  cn : String;
  prefix : String;

    checkonly domain uml c : UML::Class {
      ...
QVT Relacional - Valoración

  :-)     Paso de parámetros en where

  :-)     Clausulas en when son consultas de la traza
...
Tefkat
  The Engine Formerly Known As Tarzan
          DSTC submission for QVT RFP
          http://tefkat.sourceforge.net...
Tefkat
CLASS ClsToTbl {
  Class class;
  Table table;                “traza explícita”             Tracking
};            ...
Tefkat
PATTERN   ClassHasAttr(Class, Attr, Name, IsKey)
  WHERE   ClassHasSimpleAttr(Class, Attr, Name, IsKey)     Patrón
...
Tefkat

  :-)     Tracking classes

  :-)     Patrones separados de reglas


  :-(     Muy poco eficiente

  :-(     Dific...
QVT Operacional
  Query Views Transformations (OMG)
          Estándar OMG
  Imperativo. Unidireccional.
          Llamada...
QVT Operacional

main() {                                               Punto de
  uml.objectsOfType(Package)->map package...
QVT Operacional

  :-)     Intuitivo en principio

  :-)     Potente para abordar transformaciones complejas


  :-(     M...
Epsilon y Viatra
  Epsilon
          Framework de lenguajes
          http://www.eclipse.org/gmt/epsilon/
          Intera...
RubyTL
  RubyTL
          Universidad de Murcia :-)
          http://gts.inf.um.es/age
  DSL embebido en Ruby
          Re...
RubyTL

phase 'class2table' do                                           Fase
 top_rule 'class2table' do
   from ClassM::C...
RubyTL

import 'm2m://class2table', :as => 'class2table'                Importar
phase 'fkeys' do
  top_rule 'attribute2fk...
RubyTL

  :-)     Muy potente. Usable.

  :-)     Mecanismo de modularidad. Phases.


  :-(     No escala bien con modelos...
Modularidad
           superimposition vs. phases

                                          Sobreescribir
               ...
Valoración personal
  Faltan implementaciones realmente estables
          ± estables : ATL, RubyTL, Epsilon
  Reutilizaci...
Upcoming SlideShare
Loading in …5
×

Lenguajes de Transformación

4,027 views

Published on

Published in: Technology
  • Be the first to comment

Lenguajes de Transformación

  1. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 20. Tefkat :-) Tracking classes :-) Patrones separados de reglas :-( Muy poco eficiente :-( Dificil hacerlo funcionar 2/12/08 Jesús Sánchez Cuadrado 20
  21. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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

×