• A code analysis approach to extract NoSQL logical schemas with both reference and aggregation relationships, using a generic metamodel (U-Schema) suitable for multimodel database tools. • The approach enables the automation of database refactorings, including join elimination through field duplication to improve query performance. • The process relies on platform-independent metamodels to represent code, control flow, and data operations, ensuring extensibility and language-agnostic reuse. • The approach incorporates dedicated algorithms for model transformation, from control flow extraction to schema inference and refactoring plan generation. Most NoSQL systems adopt a schema-on-read approach to promote flexibility and agility: the structure of the stored data is not constrained by predefined schemas. However, the absence of explicit schema declarations does not imply the absence of schemas themselves. In practice, schemas are implicit in both the application code and the stored data, and are essential for building tools such as data modelers, query optimizers, data migrators, or for performing database refactorings. As a result, NoSQL schema inference (also known as schema extraction or discovery) has gained attention from the database community, with most approaches focusing on extracting schemas from data. In contrast, the source code analysis remains less explored for this purpose. In this paper, we present a static code analysis strategy to extract logical schemas from NoSQL applications. Our solution is based on a model-driven reverse engineering process composed of a chain of platform-independent model transformations. The extracted schema conforms to the U-Schema unified metamodel, which can represent both NoSQL and relational schemas. To support this process, we define a metamodel capable of representing the core elements of object-oriented languages. Application code is first injected into a code model, from which a control flow model is derived. This, in turn, enables the generation of a model representing both data access operations and the structure of stored data. From these models, the U-Schema logical schema is inferred. Additionally, the extracted information can be used to identify refactoring opportunities. We illustrate this capability through the detection of join-like query patterns and the automated application of field duplication strategies to eliminate expensive joins. All stages of the process are described in detail, and the approach is validated through a round-trip experiment in which a application using a MongoDB store is automatically generated from a predefined schema. The inferred schema is then compared to the original to assess the accuracy of the extraction process.

In the same way as with relational systems, schema evolution is a crucial aspect of NoSQL systems. But providing approaches and tools to support NoSQL schema evolution is more challenging than for relational databases. Not only are most NoSQL systems schemaless, but different data models exist without a standard specification for them. Moreover, recent proposals fail to address some key aspects related to the kinds of relationships between entities, the definition of relationship types, and the support of structural variation. In this article, we present a generic schema evolution approach able to support the most popular NoSQL data models (columnar, document, key-value, and graph) and the relational model. The proposal is based on the Orion language that implements a schema change operation taxonomy defined for the U-Schema unified data model that integrates NoSQL and relational abstractions. The consistency of the taxonomy operations is formally evaluated with Alloy, and the Orion semantics is expressed by translating operations into native code to update data and schema. Several database systems are supported, and the engine built for each of them has been validated by testing each individual SCO and refactoring study cases. A study of relative execution time of operations is also shown.

Most NoSQL systems are schema-on-read: data can be stored without first having to declare a schema that imposes a structure. This schemaless feature offers flexibility to evolve data-intensive applications when data change frequently. However, freeing from declaring schemas does not mean their absence, but rather that they are implicit in data and code. Therefore, diagramming tools similar to those available for relational systems are also needed to help developers and administrators to design and to understand NoSQL schemas. Visualizing diagrams is not practical if schemas contain hundreds of database entities, so exploration or query facilities are then needed. In schemaless NoSQL stores, data of the same entity can be stored with different structure (e.g., non-uniform types and optional fields), which can increase the difficulty of having readable diagrams. NoSQL schema management tools should therefore have three main components: schema extraction, schema visualization, and schema query. As there are four main NoSQL data models, it is convenient for such tools to be built on a generic data model so that they provide platform-independence (of data models and data stores) to query and visualize schemas. With the aim of favoring the creation of generic database tools, the authors of this paper defined the U-Schema unified data model that integrates the four main NoSQL data models as well as the relational model. This paper is focused on querying NoSQL and relational schemas which are represented as U-Schema models. We present the SkiQL language designed on U-Schema to achieve a platform-independent schema query service. SkiQL provides two constructs: schema-query and relationship-query. The former allows to obtain information of entity or relationship types, and the latter that of the aggregations or references (relations among types). We will show how SkiQL was evaluated by calculating well-known metrics for languages as well as using a survey with developers with experience in NoSQL.

The Database field is undergoing significant changes. Although relational systems are still predominant, the interest in NoSQL systems is continuously increasing. In this scenario, polyglot persistence is envisioned as the database architecture to be prevalent in the future. Therefore, database tools and systems are evolving to support several data models. Multi-model database tools normally use a generic or unified metamodel to represent schemas of the data model that they support. Such metamodels facilitate developing database utilities, as they can be built on a common representation. Also, the number of mappings required to migrate databases from a data model to another is reduced, and integrability is favored. In this paper, we present the U-Schema unified metamodel able to represent logical schemas for the four most popular NoSQL paradigms (columnar, document, key–value, and graph) as well as relational schemas. We will formally define the mappings between U-Schema and the data model defined for each database paradigm. How these mappings have been implemented and validated will be discussed, and some applications of U-Schema will be shown. To achieve flexibility to respond to data changes, most of NoSQL systems are “schema-on-read,” and the declaration of schemas is not required. Such an absence of schema declaration makes structural variability possible, i.e., stored data of the same entity type can have different structure. Moreover, data relationships supported by each data model are different; For example, document stores have aggregate objects but not relationship types, whereas graph stores offer the opposite. Through the paper, we will show how all these issues have been tackled in our approach. As far as we know, no proposal exists in the literature of a unified metamodel for relational and the NoSQL paradigms which describes how each individual data model is integrated and mapped. Our metamodel goes beyond the existing proposals by distinguishing entity types and relationship types, representing aggregation and reference relationships, and including the notion of structural variability. Our contributions also include developing schema extraction strategies for schemaless systems of each NoSQL data model, and tackling performance and scalability in the implementation for each store.

Summary Creating quality online content requires a great deal of effort from teachers. In addition to issues specific to the design and creation of the elements of a course, teachers must face technical hurdles so as to perform common tasks, such as deploying the same content on different e‐learning platforms and integrating content into external tools, or acquiring the ability to analyze tracking data generated during learner interactions. These problems principally arise owing to the very limited level of interoperability provided by content creation tools. In order to facilitate the creation of interoperable contents, the Digital Content Production Center at the Polytechnic University of Cartagena (Spain) has developed the UPCTforma tool, whose main architectural driver has been interoperability. More specifically, the tool takes advantage of the Learning Tools Interoperability and Caliper interoperability specifications to provide several types of quality regarding three key aspects of content production: tool interoperability, learning analytics, and motivation. In this paper, we provide a detailed description of the component‐based architecture proposed and present a validation of the requirements elicited through the use of a UPCTforma gamification activity created for a real project involving approximately 4000 students. One of the novel aspects of this architecture is the transformation of tracking data into “learning analysis models” that represent the information in the tracked learning activities at a higher level of abstraction. These models are used to provide activity‐specific learning analytics and motivation. Platform independency with respect to data analytics technologies, messaging systems, and communication protocols is achieved by using adapters.

In building software systems, the integration of tools with the purpose of exchanging data (i.e. tool interoperability) is common practice. Such an integration is one of the application scenarios of Model-Driven Engineering (MDE), which is often called Model-Driven Interoperability (MDI). In the last few years, some MDI approaches have been presented, and they have shown how MDE techniques are useful in bridging tools in order to integrate data. However, the number of case studies is still limited and more practical experiences of building MDI bridges should be published. In this article, we present an MDI bidirectional bridge that integrates the Objectiver and DB-Main tools. DB-Main database schemas are obtained from Objectiver object models, and they are kept consistent. Through this case study, we contrast the majority of techniques that can be used to implement a MDI solution. We mainly focus on the level of automation offered by each alternative. Some lessons learned are commented on.

This paper addresses the problem of modernizing graphical user interfaces of interactive applications by re-engineering their resource files in four phases: resource decompilation, which extracts resource files from the executable code of an interactive application; modeling the source user interface, which transforms extracted resources into a resource model; resource to user interface transformation, which transforms the resource model into a Concrete User Interface model, and forward engineering, which offers two alternatives: after editing the user interface model, a new interface could be generated or recompiled into a resource to be incorporated back. The paper motivates and details this re-engineering approach by focusing on methods and algorithms implemented in UsiResourcer, a software tool that reverse engineers MS Windows resource files into a Concrete User Interface Model for further process. A discussion on the generalization of the approach is also provided.

Businesses are more and more modernizing the legacy systems they developed with Rapid Application Development (RAD), so that they can benefit from the new platforms and technologies. In these systems, the Graphical User Interface (GUI) layout is implicitly given by the position of the GUI elements (i.e. coordinates). However, taking advantage of current features of GUI technologies often requires an explicit, high-level layout model. We propose a Model-Driven Engineering process to perform reverse engineering of RAD-built GUIs, which is focused on discovering the implicit layout, and produces a GUI model where the layout is explicit. Based on the information we obtain, other reengineering activities can be performed, for example, to adapt the GUI for mobile device screens.

With the emergence of model-driven engineering (MDE), the creation of domain-specific languages (DSLs) is becoming a fundamental part of language engineering. The development cost of a DSL should be modest compared to the cost of developing a general-purpose programming language. Reducing the implementation effort and providing reuse techniques are key aspects for DSL approaches to be really effective. In this paper, we present an approach to build embedded domain-specific languages applying the principles of model-driven engineering. On the basis of this approach, we will tackle reuse of DSLs by defining families of DSLs, addressing reuse both from the DSL developer and user point of views. A family of DSLs will be built up by composing several DSLs, so we will propose composition mechanisms for the abstract syntax, concrete syntax, and model transformation levels of a DSL's definition. Finally, we contribute a software framework to support our approach, and we illustrate the paper with a case study to demonstrate its practical applicability.