QVT Relations Research Articles

Implementing QVT-R via semantic interpretation in UML-RSDS

The QVT-Relations (QVT-R) model transformation language is an OMG standard notation for model transformation specification. It is highly declarative and supports (in principle) bidirectional (bx) transformation specification. However, there are many unclear or unsatisfactory aspects to its semantics, which is not precisely defined in the standard. UML-RSDS is an executable subset of UML and OCL. It has a precise mathematical semantics and criteria for ensuring correctness of applications (including model transformations) by construction. There is extensive tool support for verification and for production of 3GL code in multiple languages (Java, C#, C++, C, Swift and Python). In this paper, we define a translation from QVT-R into UML-RSDS, which provides a logically oriented semantics for QVT-R, aligned with the RelToCore mapping semantics in the QVT standard. The translation includes variation points to enable specialised semantics to be selected in particular transformation cases. The translation provides a basis for verification and static analysis of QVT-R specifications and also enables the production of efficient code implementations of QVT-R specifications. We evaluate the approach by applying it to solve benchmark examples of bx.

Round-trip Engineering UML Class Models and Java Models

Model transformations constitute the key technology for model-driven software development, a software engineering discipline which became more and more important during the last decade. While tool support for unidirectional batch transformations is rather mature, bidirectional and incremental transformations are only weakly investigated. Nevertheless, several usage scenarios demand for incremental and bidirectional transformations, like round-trip engineering between UML class models and Java source code. This paper presents a bidirectional transformation between UML class models and a Java model which is obtained from Java source code. The transformation is written in QVT Relations, a declarative model transformation language provided by the OMG. While the case study demonstrates that it is possible to specify bidirectional transformations between heterogeneous metamodels in a single relational specification, it also reveals some inherent limitations of the language and the corresponding tool support.

Case-based exploration of bidirectional transformations in QVT Relations

QVT Relations (QVT-R), a standard issued by the Object Management Group, is a language for the declarative specification of model transformations. This paper focuses on a particularly interesting feature of QVT-R: the declarative specification of bidirectional transformations. Rather than writing two unidirectional transformations separately, a transformation developer may provide a single relational specification which may be executed in both directions. This approach saves specification effort and ensures the consistency of forward and backward transformations. This paper explores QVT-R’s support for bidirectional model transformations through a spectrum of transformation cases. The transformation cases vary with respect to several factors such as the size of the transformation definition or the relationships between the metamodels for source and target models. The cases are solved in QVT-R, but may be applied to other bidirectional transformation languages, as well; thus, they may be used as a benchmark for comparing bidirectional transformation languages. In our work, we focus on the following research questions: functionality of bidirectional transformations in terms of relations between source and target models, solvability (which problems may be solved by a single relational specification of a bidirectional transformation), variability (does a bidirectional transformation contain varying elements, i.e., elements being specific to one direction), comprehensibility (referring to the ease of understanding and constructing QVT-R transformations), and the semantic soundness of bidirectional transformations written in QVT-R.

A metamodel-based definition of a conversion mechanism between SOAP and RESTful web services

Nowadays there are several frameworks that permit the conversion between SOAP and RESTful web services. However, none of these frameworks defines a high-level characterization of the interchange process, hindering full understanding of this process. This paper provides a metamodel-based approach that formalizes the conversion between SOAP and RESTful web services, clarifying this process. This approach can be used for guiding the ranslation process in forthcoming conversion frameworks and the publication of services in IDEs. In order to characterize the conversion mechanism three MOF metamodels are defined: SOAP, RESTful and intermediate SOA metamodels. This intermediate metamodel is used as a bridge between the other two metamodels. QVT Relations transformation rules between SOAP, RESTful and SOA metamodels are defined for a formal characterization of the transformation process.

Towards an automatic model transformation mechanism from UML state machines to DEVS models

The development of complex event-driven systems requires studies and analysis prior to deployment with the goal of detecting unwanted behavior. UML is a language widely used by the software engineering community for modeling these systems through state machines, among other mechanisms. Currently, these models do not have appropriate execution and simulation tools to analyze the real behavior of systems. Existing tools do not provide appropriate libraries (sampling from a probability distribution, plotting, etc.) both to build and to analyze models. Modeling and simulation for design and prototyping of systems are widely used techniques to predict, investigate and compare the performance of systems. In particular, the Discrete Event System Specification (DEVS) formalism separates the modeling and simulation; there are several tools available on the market that run and collect information from DEVS models. This paper proposes a model transformation mechanism from UML state machines to DEVS models in the Model-Driven Development (MDD) context, through the declarative QVT Relations language, in order to perform simulations using tools, such as PowerDEVS. A mechanism to validate the transformation is proposed. Moreover, examples of application to analyze the behavior of an automatic banking machine and a control system of an elevator are presented.

Live data migration approach from relational tables to schema-free collections with MapReduce

Although NoSQL has some new features to address the query bottleneck of big data, the hybrid solution of relational database and NoSQL will last for a long period. Therefore, recent researches focus on the data migration issue from relational database to document stores. However, there are few publications on live data migration in parallel. In this paper, we attempt to address this old problem using new MapReduce framework. The process of migration consists of log-based change data capture, merging of changed data, and blocking and transformation. We utilise predicate logic of mathematical relation and QVT relations to describe the mapping rules clearly. Finally, our experimental evaluation of log-based blocking and transformation with MapReduce shows the higher effectiveness and efficiency than current methods.

Least-change bidirectional model transformation with QVT-R and ATL

QVT Relations (QVT-R) is the standard language proposed by the OMG to specify bidirectional model transformations. Unfortunately, in part due to ambiguities and omissions in the original semantics, acceptance and development of effective tool support have been slow. Recently, the checking semantics of QVT-R has been clarified and formalized. In this article, we propose a QVT-R tool that complies to such semantics. Unlike any other existing tool, it also supports meta-models enriched with OCL constraints (thus avoiding returning ill-formed models) and proposes an alternative enforcement semantics that works according to the simple and predictable “principle of least change.” The implementation is based on an embedding of both QVT-R transformations and UML class diagrams (annotated with OCL) in Alloy, a lightweight formal specification language with support for automatic model finding via SAT solving. We also show how this technique can be applied to bidirectionalize ATL, a popular (but unidirectional) model transformation language.

Colouring: execution, debug and analysis of QVT-relations transformations through coloured Petri nets

QVT is the standard language sponsored by the OMG to specify model-to-model transformations. It includes three different languages, being QVT-relations (QVT-R) the one with higher-level of abstraction. Unfortunately, there is scarce tool support for it nowadays, with incompatibilities and disagreements between the few tools implementing it, and lacking support for the analysis and verification of transformations. Part of this situation is due to the fact that the standard provides only a semi-formal semantics for QVT-R. In order to alleviate this situation, this paper provides a semantics for QVT-R through its compilation into coloured Petri nets. The theory of coloured Petri nets provides useful techniques to analyse transformations (e.g. detecting relation conflicts, or checking whether certain structures are generated or not in the target model) as well as to determine their confluence and termination given a starting model. Our semantics is flexible enough to permit the use of QVT-R specifications not only for transformation and check-only scenarios, but also for model matching and model comparison, not covered in the original standard. As a proof of concept, we report on the use of CPNTools for the execution, debugging, verification and validation of transformations, and on a tool chain (named Colouring) to transform QVT-R specifications and their input models into the input format of CPNTools, as well as to export and visualize the transformation results back as models.

Retainment policies – A formal framework for change retainment for trace-based model transformations

Model-to-model (M2M) transformations play an important role within model-driven development. Modern M2M approaches support incremental updates to the target model according to changes in the source model(s). Bidirectional transformation approaches even allow to incrementally translate target model changes back to the source model. A model transformation’s target model may need to be refined later on either manually or automatically. Therefore, modellers may want to specify that target model changes are not overwritten if the original transformation is re-executed. There is currently only weak support for this kind of retainment by transformation engines. In many transformation engines a transformation trace is available which keeps record of a transformation’s actions. In this paper, we exploit this information and define patterns which allow transformation engineers to trim transformations to facilitate the handling of target model changes. We describe a formal framework which serves as basis for realizing the patterns as what we call retainment policies. Based on this framework we present an implementation of the retainment policy approach for QVT Relations. The retainment policies which allow a transformation developer to develop transformation rules that will retain manual changes to the target model. The implementation of the approach for QVT Relations shows that it is realisable in state-of-the art transformation techniques. However, being defined on a theoretical level, also other transformation approaches will benefit from our work.

Model querying with graphical notation of QVT relations

As a standard high-level model transformation language, QVT Relations defines a graphical notation, which provides a concise, intuitive way to specify transformations. However, QVT Relations relies only on the textual language OCL for model querying, leading to verbose and complicated OCL expressions. Here, we present a graphical model query facility based on the checking semantics and pattern matching of QVT Relations. The query facility also borrows from QVT Relations the graphical notation. In addition we propose an approach to map the queries into XSLT to facilitate their execution. We have developed a tool for designing the queries and automatically generating the XSLT programs.

REVERSIBLE LOSSLESS TRANSFORMATION FROM OWL 2 ONTOLOGIES INTO RELATIONAL DATABASES

The goal of the paper is to define reversible, information preserving transformation from OWL 2ontologies into relational databases using our proposed hybrid approach, when a part of ontology constructs is directlyrepresented by relational database structures and another part having no direct correspondences in a relational databaseis stored in metadata tables. The desirable transformation is defined in QVT Relations language following additionalrequirements under which such transformation is reversible and does not lose semantic information when performingfrom ontology to database and backward.http://dx.doi.org/10.5755/j01.itc.40.4.979

Solving the TTC 2011 Compiler Optimization Case with QVTR-XSLT

In this short paper we present our solution for the Compiler Optimization case study of the Transformation Tool Contest (TTC) 2011 using the QVTR-XSLT tool. The tool supports editing and execution of the graphical notation of QVT Relations language

Saying HelloWorld with QVTR-XSLT — A Solution to the TTC 2011 Instructive Case

In this short paper we present our solution for the Hello World case study of the Transformation Tool Contest (TTC) 2011 using the QVTR-XSLT tool. The tool supports editing and execution of the graphical notation of QVT Relations language. The case study consists of a set of simple transformation tasks which covers the basic functions required for a transformation language, such as creating, reading/querying, updating and deleting of model elements. We design a transformation for each of the tasks.

A simple game-theoretic approach to checkonly QVT Relations

The QVT Relations (QVT-R) transformation language allows the definition of bidirectional model transformations, which are required in cases where two (or more) models must be kept consistent in the face of changes to either or both. A QVT-R transformation can be used either in checkonly mode, to determine whether a target model is consistent with a given source model, or in enforce mode, to change the target model. A precise understanding of checkonly mode transformations is prerequisite to a precise understanding of enforce mode transformations, and this is the focus of this paper. In order to give semantics to checkonly QVT-R transformations, we need to consider the overall structure of the transformation as given by when and where clauses, and the role of trace classes. In the standard, the semantics of QVT-R are given both directly, and by means of a translation to QVT Core, a language which is intended to be simpler. In this paper, we argue that there are irreconcilable differences between the intended semantics of QVT-R and those of QVT Core, so that no translation from QVT-R to QVT Core can be semantics-preserving, and hence no such translation can be helpful in defining the semantics of QVT-R. Treating QVT-R directly, we propose a simple game-theoretic semantics. We demonstrate its behaviour on examples and show how it can be used to prove an example result comparing two QVT-R transformations. We demonstrate that consistent models may not possess a single trace model whose objects can be read as traceability links in either direction. We briefly discuss the effect of variations in the rules of the game, to elucidate some design choices available to the designers of the QVT-R language.

QVT-based model transformation using XSLT

Model transformations are one of the key technologies in modelbased development. The graphical notation of relational QVT provides a concise, intuitive way to specify transformations. But this notation is not directly applicable for practitioners because of the lack of tool support. On the other hand, XSLT is a common and powerful language for XML transformations, but not suitable for directly programming transformations of semantically complex models due to its low level syntax. We combine the best of both techniques by using QVT graphical notation to specify a transformation as a set of QVT relations, and implementing each relation as an XSLT rule template. A prototype tool with a QVT graphical editor and an automatic XSLT program generator has been developed to support the approach.

Module superimposition: a composition technique for rule-based model transformation languages

As the application of model transformation becomes increasingly commonplace, the focus is shifting from model transformation languages to the model transformations themselves. The properties of model transformations, such as scalability, maintainability and reusability, have become important. Composition of model transformations allows for the creation of smaller, maintainable and reusable transformation definitions that together perform a larger transformation. This paper focuses on composition for two rule-based model transformation languages: the ATLAS Transformation Language (ATL) and the QVT Relations language. We propose a composition technique called module superimposition that allows for extending and overriding rules in transformation modules. We provide executable semantics as well as a concise and scalable implementation of module superimposition based on ATL.

Formal Model Merging Applied to Class Diagram Integration

The integration of software artifacts is present in many scenarios of the Software Engineering field: object-oriented modeling, relational databases, XML schemas, ontologies, aspect-oriented programming, etc. In Model Management, software artifacts are viewed as models that can be manipulated by means of generic operators, which are specified independently of the context in which they are used. One of these operators is Merge, which enables the automated integration of models. Solutions for merging models that are achieved by applying this operator are more abstract and reusable than the ad-hoc solutions that are pervasive in many contexts of the Software Engineering field. In this paper, we present our automated approach for generic model merging from a practical standpoint, providing support for conflict resolution and traceability between software artifacts by using the QVT Relations language. We focus on the definition of our operator Merge, applying it to Class Diagrams integration.