Your SlideShare is downloading. ×
Lenguajes de Transformación
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Lenguajes de Transformación

3,316

Published on

Published in: Technology
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
3,316
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
63
Comments
0
Likes
2
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 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

×