SQL-PL4OCL: An Automatic Code Generator from OCL to SQL Procedural Language

The import coupling of an object constraint language (OCL) expression increases when the expression operates within a large context of a Unified Modelling Language (UML) model. The expression would thus exhibit a decrease in its comprehensibility, and in consequence, the maintainability of the OCL expressions could be affected, due to the fact that modelers need to know all the artifacts upon which the expression relies. In order to explain the cognitive complexity of modelers dealing with OCL expressions with high import- coupling we have carried out a think aloud experiment which is described in detail in this paper. The experiment is part of a project which we are developing with the goal of obtaining valid measures through which to assess the influence of import coupling on OCL expression maintainability. The empirical results show evidence that: (1) reified objects, problem objects and their relationships constitute the main components of the cognitive complexity of modelers; (2) modelers use different cognitive approaches to comprehend an OCL expression within a UML/OCL model.

Object constraint language for code generation from activity models

The Object Constraint Language (OCL) has been for many years formalized both in its syntax and semantics in the language standard. While the official definition of OCL’s syntax is already widely accepted and strictly supported by most OCL tools, there is no such agreement on OCL’s semantics, yet. In this paper, we propose an approach based on metamodeling and model transformations for formalizing the semantics of OCL. Similarly to OCL’s official semantics, our semantics formalizes the semantic domain of OCL, i.e. the possible values to which OCL expressions can evaluate, by a metamodel. Contrary to OCL’s official semantics, the evaluation of OCL expressions is formalized in our approach by model transformations written in QVT. Thanks to the chosen format, our semantics definition for OCL can be automatically transformed into a tool, which evaluates OCL expressions in a given context. Our work on the formalization of OCL’s semantics resulted also in the identification and better understanding of important semantic concepts, on which OCL relies. These insights are of great help when OCL has to be tailored as a constraint language of a given DSL. We show on an example, how the semantics of OCL has to be redefined in order to become a constraint language in a database domain.

Software testing is one activity for Software Quality Assurance (SQA). One way to test is through Black box test cases at design level. Since UML is a de-facto design language and is one of the most used design language now a day. Therefore, there is need to design black box test cases using UML behavioral diagrams. Object Constraint Language (OCL) is a formal language to write constraints on UML diagrams as it is unambiguous. Although test cases against robustness have been designed through OCL expressions but no test cases as yet have been designed against security specific authentication, access control and availability. Specification and testing of security specific authentication, access Control and availability through OCL. An experiment is performed with a hypothesis ‘if Security Specific Authentication, Access Control and Availability is specified through OCL in state diagram then Test cases can be designed’. We have specifiedsecurity in OCL then same OCL expressions are used to model security in UML state diagram. Furthermore, mutation testing is performed on OCL expressions. Then ECP is done using same extracted mutants. Security specific authentication, access control and availability is specified in OCL and then test cases are designed using a black box testing technique Equivalence Class Partitioning. Hypothesis results shows that one can design test cases through OCL. This thesis shows that Specification and Testing of Security specific authentication, access control and availability through OCL.

The Object Constraint Language (OCL) is a OMG standard that plays an important role in the elaboration of precise models. However, it is not hard to find models and metamodels containing overly complex OCL expressions. Refactoring is a technique that can be used in this context since its goal is to reduce complexity by incrementally improving the internal software quality. Indeed several refactorings have already been proposed to improve the quality of OCL expressions. This paper presents the results of an empirical study that investigates the impact of poor OCL constructs, also known as OCL Smells, and OCL refactorings on the understandability of OCL expressions. Current results show that most refactorings significantly improve the understandability of OCL specifications.

The textual Object Constraint Language (OCL) is primarily intended to specify restrictions over UML class diagrams, in particular class invariants, operation pre-, and postconditions. Based on several improvements in the definition of the language concepts in last years, a proposal for a new version of OCL has recently been published [43]. That document provides an extensive OCL semantic description that constitutes a tight integration into UML. However, OCL still lacks a semantic integration of UML Statecharts, although it can already be used to refer to states in OCL expressions. This article presents an approach that closes this gap and introduces a formal semantics for such integration through a mathematical model. It also presents the definition of a temporal OCL extension by means of a UML Profile based on the metamodel of the latest OCL proposal. Our OCL extension enables modelers to specify behavioral state-oriented real-time constraints. It provides an intuitive understanding and readability at application level since common OCL syntax and concepts are preserved. A well-defined formal semantics is given through the mapping of temporal OCL expressions to temporal logics formulae.

Model Driven Engineering (MDE) is an important software development paradigm. Within this paradigm, models and constraints are essential components for expressing specifications of a software artefact. Object Constraint Language (OCL), a specification language that allows users to freely express constraints over different model features. However, one major issue is that the lack of OCL benchmarks makes difficult to evaluate existing and newly created OCL tools. In this paper, we present our initial idea about automatic OCL benchmark generation. The purpose of this paper is to show a developing idea rather than presenting a more formal and complete approach. Our idea is to use an OCL metamodel to sketch abstract syntax trees for OCL expressions, and solve generated typing constraints to produce the concrete OCL expressions. We illustrate this idea by using an example, discuss our work-in-progress and outline challenges to be tackled in the future.

Today, model-driven approaches are a cornerstone in modern software development. The Eclipse Modeling Framework (EMF) is highly adopted in practice and generates Java code from platform-independent models with embedded Object Constraint Language (OCL) expressions. However, applications that target multiple platforms like Android, iOS, Windows, web browsers usually need to be implemented in different programming languages. Feature-complete Ecore and OCL runtime APIs are not available for all these platforms, such that their functionality has to be re-implemented. In this paper, we present CrossEcore: A multi-platform enabled modeling framework that generates C#, Swift, TypeScript, and JavaScript code from Ecore models with embedded OCL. An OCL compiler translates OCL expressions into expressions of the target language. The Ecore and OCL API can be consistently used across platforms, which facilitates application portability. CrossEcore is also extendible and can be easily adopted for new programming languages.

The Object Constraint Language (OCL) is a textual, declarative language typically used as part of the UML standard for specifying constraints and queries on models. Several attempts have been proposed in the past for translating OCL expressions into SQL queries in the context of Model Driven Engineering (MDE). To cope with OCL expressions that include iterators, previous attempts resorted to imperative features (loops, cursors) of SQL, with the consequent loss of efficiency. In this paper, we define (and implement) a novel mapping from OCL to SQL that covers (possibly nested) iterators, without resorting to imperative, non-declarative features of SQL. We show with a preliminary benchmark that our mapping generates SQL queries that can be efficiently executed on mid- and large-size SQL databases.

In this paper, we introduce a SQL-PL code generator for OCL expressions that, in contrast to other proposals, is able to map OCL iterate and iterator expressions thanks to our use of stored procedures. We explain how the mapping presented here introduces key differences to the previous version of our mapping in order to (i) simplify its definition, (ii) improve the evaluation time of the resulting code, and (iii) consider OCL three-valued evaluation semantics. Moreover, we have implemented our mapping to target several relational database management systems, i.e., MySQL, MariaDB, PostgreSQL, and SQL server, which allows us to widen its usability and to benchmark the evaluation time of the SQL-PL code produced.

This methodological paper introduces a Structured Chinese Query Language (SCHQL), an author-designed SQL parser/translator for enhancing the accessibility and usability of Relational Database Management Systems (RDBMS) for Chinese language users by facilitating the translation of SQL (structured query language) keywords into Chinese. The PHP language is used as front-end to the RDBMS (relational database management system) enabling users to perform Create, Read, Update, and Delete (CRUD) operations directly within the browser’s query editor using Chinese characters replacing English key-words shown in the keyword pairs array of the script. While no participants were involved in this study, the parser has the potential to alleviate cognitive load, making database interactions more intuitive for non-English (Chinese) speakers. Cognitive load is not researched here, however it is discussed and referenced. The parser has been tested, with results demonstrated in the figures presented. This paper details the development, implementation, and evaluation of SCHQL, underscoring its potential to bridge the language gap in RDBMS interaction, not just in Chinese language domain but other language pairs as well. Future research is open to user testing to assess the tool's effectiveness and usability across diverse languages, potentially contributing to global SQL accessibility. This project is compliant with the Inclusive Language Guide (American Psychological Association, n.d.).

This paper aims to develop the algorithms to translate and back-translate the OCL (Object Constraint Language) into SQL (Structure Query Language). The translation will use word substring and word comparing. The OCL or SQL to word substring and word compare the algorithm. To consider a table name, relation name and conditions can be set the three sections into language model and showed the result to the users. It can help reducing time and errors of the translation. Moreover, it increases convenience for the users to translate and back-translate of OCL constraints to SQL expressions.

A set of rules to integrate Object Constraint Language (OCL) and the RALSE Specification Language (RSL) are shown and discussed. The rules presented here cover the translation of OCL expressions to semantically equivalent RSL expressions. The proposed rules here complete our previous work where we showed how to derive an initial formal specification in RSL from a UML class diagram, illustrated the use of RSL and OCL integration via an example, and proposed a complementary subset of rules for the translation of types and operations. We also present here a brief explanation of previous work on which the transformation rules are based.

The Object Constraint Language (OCL) has become a vital part of many frameworks, tools and languages within model-driven engineering. One such application of OCL is the use for describing rules in concrete syntax definitions. Within the textual modeling framework FURCAS, OCL is extensively used for the definition of lookup and attribution rules. Based on these rules the model which is described by such a textual representation is created and updated accordingly. Changes on models over which such an expression is specified require the expression to be re-evaluated to keep the constructed model up-to-date. However, the effort for re-evaluating OCL expressions over a set of model elements grows with the number of elements, the complexity of the expressions, and the number of model changes. Thus, having large models and/or complex expressions places considerable performance costs on OCL evaluation. Techniques to reduce this effort have been presented in previous work but do not cover the full range of OCL expressions, in particular calls to operations defined in OCL, including recursive operations. In this paper, we present an approach that is applicable to the full range of OCL expressions. We validated our approach based on a large set of models and complex expressions to evaluate the performance impact of our newly introduced techniques.

In this work, we go a step further in the integration of the RAISE specification language (RSL) and the unified modeling language (UML). On the basis of our previous work -where we showed how to derive an initial formal specification in RSL from a UML class diagram-we propose here the use of set of rules to transform object constraint language (OCL) expressions into RSL expressions. Class diagrams can be enhanced with annotated OCL invariants and the corresponding formalizations in RSL can be obtained. Property verification of the model described by the UML class diagram and OCL invariants can now take place on the derived RSL specification by using reasoning techniques supported by the RAISE method.