RDF is being increasingly considered in a broad range of information management scenarios. Governments, large corporations, startups, and other organizations around the world are using RDF as a data model to represent and share knowledge. However, there is still a long evolutionary track with multiple challenges for RDF reaching the scale of the most recent Big Data intensive applications (e.g., Smart Cities, Sensor Networks, eHealth, Internet of Things). In this survey, we review the usage of NoSQL databases to the storage of large RDF graphs by rehearsing the latest surveys and expanding their findings by updating proposals and bringing light to aspects such as model mapping between RDF and NoSQL, triple indexing and partitioning, graph fragmentation and data caching. Moreover, we explain how the surveyed works extended the RDF capabilities so the datasets can benefit of the characteristics of scalability, schemaless data, and better overall performance of NoSQL databases. The survey summarizes the current state of art, discusses open problems, and proposes a Reference Architecture (RA). For the best of our knowledge, this is the first survey where the focus is solely on papers that use one or more NoSQL systems for the RDF persistence.

A data lake is a relatively recent technology to maintain and allow access to voluminous and heterogeneous data sources. Governments, large corporations and startups have increasingly considered it for storing useful data and obtain valuable business trends. However, there is still a long evolutionary path related to data lake management, where data security is an open issue. In this paper we investigate confidentiality issues in the context of data lakes, with a focus on authentication and authorization. We apply a systematic review methodology focusing on approaches that provide some technology for authentication and authorization management. In the following, we compare the selected studies w.r.t. the used technologies and we also analyze how they are positioned w.r.t. a reference architecture for a data lake management system. This is the first paper that presents such a kind of analysis for data lakes.

Several application domains deal with the management of massive data volumes and thousands of OLTP transactions per second. Traditional relational databases cannot cope with these requirements. NewSQL is a new generation of databases that provides both high scalability and availability and ACID properties support. Besides, it is a promising solution to handle these application data management needs. Although data partitioning is an essential feature for tuning relational databases, stills an open issue for NewSQL systems. In this paper, we propose a hybrid partitioning approach for NewSQL databases that allows the user to define the vertical and horizontal data partitions. In order to determine what site will store each data fragment, we propose a hash function that considers schema information and data access statistics. Our experimental evaluation compares our hybrid VoltDB version against the standard VoltDB. The results highlight that our strategy increases the number of single-site transactions from 37% to 76%.

Several applications require to handle large and heterogeneous data volumes as well as thousands of OLTP transactions per second. Traditional relational databases are not suitable for these requirements. On the other hand, NoSQL databases are able to deal with Big Data, but lacks the support to the traditional ACID properties. NewSQL is a new class of databases that combines the support to OLTP transactions of relational databases with the high availability and scalability of NoSQL databases. However, few works in the literature explore the differences among different NewSQL solutions. In this paper, we discuss the main features of the most prominent NewSQL products, besides we present benchmarking results for analyzing their performance. We believe that both analysis can be useful as a guide to a future choice of NewSQL technologies.

The microservices architecture provides a new approach to develop applications. As opposed to monolithic applications, in which the application comprises a single software artifact, an application based on the microservices architecture is composed by a set of services, each one designed to perform a single and well-defined task. These services allow the development team to decouple several parts of the application using different frameworks, languages and hardware for each part of the system. One of the drawbacks for adopting the microservices architecture to develop applications is testability. In a single application test boundaries can be more easily established and tend to be more stable as the application evolves, while with microservices we can have a set of hundreds of services that operate together and are prone to change more rapidly. Each one of these services needs to be tested and updated as the service changes. In addition, the different characteristics of these services such as languages, frameworks or the used infrastructure have to be considered in the testing phase. Performance tests are applied to assure that a particular software complies with a set of non-functional requirements such as throughput and response time. These metrics are important to ensure that business constraints are respected and to help finding performance bottlenecks. In this paper, we present a new approach to allow the performance tests to be executed in an automated way, with each microservice providing a test specification that is used to perform tests. Along with the architecture, we also provide a framework that implements some key concepts of this architecture. This framework is available as an open source project1.

This paper presents a web framework for test automation. This framework automates tests specified using the technique User Scenarios through User Interaction Diagrams (US-UID). US-UIDs represent customer requirements and are created a priori to the development of the application code. The goal of this proposal is the execution of US-UIDs as acceptance tests to check the application code in the context of Acceptance Test-Driven Development (ATDD). The implementation of the proposed framework uses FitNesse as its base and adds an editor for creating and executing US-UIDs. The proposal is exemplified by US-UIDs of the 8-puzzle game and evaluates the code of a Web-based application. The results show that US-UID has an executable format as automated tests. In addition, the proposed web framework has the capability of indicating the success, error or failure of interaction between a US-UID and the application code.

Nowadays, with the rise of mobile devices, users deal with applications that present user interfaces adapted to different contexts of use. In order to improve the quality of these user interfaces, we propose a solution that includes a higher level description of tests and a tool, called Segen, for generating test cases for two very known test automation tools for Web and mobile environments: Selenium and Selendroid. Segen allows to generate test scripts from a single high-level description to executable tests scripts for each environment. On using Segen, testers can focus on the test cases, independently of the environment being used. A proof of concept was used to evaluate Segen: a smart home energy management that has a Web version and a mobile Android version. The evaluation showed that Segen reduces the work of testers and can be used along with other testing libraries. The evaluation also showed that Segen is more useful if test cases are designed before the development. However, it was identified that Segen has similar limitations to those that Selenium and Selendroid have.

Microservices are replacing monolithic applications by splitting them out into small and independent artifacts that collaborate with one another. Focused on managing highly cohesive information, microservices may be composed to provide richer and linked information. This paper presents a composition method, aimed at composing semantic microservices for achieving data integration based on Linked Data principles. Moreover, the proposed method leverages the independence of development and composability of microservices. This paper also presents a framework and a case study for the proposed method.

NoSQL databases are designed to manage large volumes of data. Although they do not require a default schema associated with the data, they are categorized by data models. Because of this, data organization in NoSQL databases needs significant design decisions because they affect quality requirements such as scalability, consistency and performance. In traditional database design, on the logical modeling phase, a conceptual schema is transformed into a schema with lower abstraction and suitable to the target database data model. In this context, the contribution of this paper is an approach for logical design of NoSQL document databases. Our approach consists in a process that converts a conceptual modeling into efficient logical representations for a NoSQL document database. Workload information is considered to determine an optimized logical schema, providing a better access performance for the application. We evaluate our approach through a case study in the e-commerce domain and demonstrate that the NoSQL logical structure generated by our approach reduces the amount of items accessed by the application queries.

Today, many applications produce and manipulate a large volume of data, the so-called Big Data. Traditional databases (DB), like relational databases, are not suitable to Big Data management. In order to solve this problem, a new category of DB has been proposed, the so-called NoSQL DB. NoSQL DB have different data models, as well as different access methods which are not usually compatible with the SQL language. In this context, approaches have been proposed for providing mapping of relational DB schemata and operations to equivalent ones in NoSQL DB to deal with large relational data sets in the cloud, focusing on scalability and availability. However, these approaches map relational DB only to a single NoSQL data model and, sometimes, to a specific NoSQL DB product. This paper presents SQLtoKeyNoSQL, a layer able to translate relational schemata as well as SQL commands to equivalent schemata and access methods to any key-oriented NoSQL DB (document-oriented, key-value and column-oriented). We present the architecture of our layer focusing on our mapping strategies, as well as some preliminary experiments that evaluate the impact of SQLtoKeyNoSQL as a solution for transparent mapping of relational DB to key-based NoSQL DB.

NoSQL databases are gaining ground due to the need for several applications to manipulate large volumes of data without worrying about database system tuning and scaling. However, many applications still use relational databases and do not want to replace their access methods in order to properly manipulate their data on the cloud using now a NoSQL technology. To deal with this problem, a relational-cloud mapping strategy, in terms of data model and data operations, is able to provide a relational view of NoSQL data, eliminating the need for adjustments in the application interface for data management. SimpleSQL is a solution for this problematic. It is a relational layer for Amazon SimpleDB, one of the most popular document NoSQL databases. Although SimpleSQL had proved to be a promising approach in terms of performance, its current version provides only the mapping of SQL DML operations. This paper presents an extension of SimpleSQL to support also DDL operations. This extension allows the creation and manipulation of the database schema from the application (client) side, abstracting any knowledge about data definition at SimpleDB. Preliminary experiments show that our solution continues to be feasible, since the overhead with DDL operations through SimpleSQL is not prohibitive.

In general, the design of XML schemas involves translating conceptual schemas into XML schemas which aim to be: (i) normalized schemas, and (ii) connected structures in order to achieve good performance on queries. However, these requirements address a trade-off because highly connected XML structures allow data redundancy, and normalized schemas generate disconnected XML structures. This paper describes a workload-based approach which balances this trade-off on translating conceptual schemas into XML structures. An experimental study on an XML database shows that our XML schemas provide high query performance on the relevant elements for the workload and, at the same time, low cost of data redundancy on elements that are not relevant for update operations.

As XML has emerged as a data representation format and as great quantities of data have been stored in the XML format, XML document design has become an important and evident issue in several application contexts. Methodologies based on conceptual modeling are being tightly applied for designing XML documents. However, the conversion of a conceptual schema to an XML schema is a complex process. In many cases, conceptual relationships cannot be represented in a hierarchy so that they have to be represented by reference relationships in the XML schema. The problem is that reference relationships generate a disconnected XML structure and, consequently, produce an overhead cost for query processing on XML documents.