An increasingly common application for DLTs is their exploitation in enterprise systems operated by a consortium of organizations, who may assume different roles and whose interaction takes place over a blockchain network (in this scope, often permissioned), which holds a data state that they need to query frequently. In this regard, one of the main drawbacks of DLTs is their unsuitability for the efficient execution of complex queries on the data stored by the nodes comprising the network. Arising from this issue, many solutions propose to dump the ledger contents into databases, which, due to their own nature and purpose, are certainly optimized for the execution of such queries. However, most proposals on this area are not intended for querying the shared state held by the network, just the transaction history. Actually, through conducting a study on the state of the art, a lack of support for handling and querying complex structured data has been identified. DELTA provides a solution for the synchronization, with negligible overload, of the state of a DLT into a database, enabling (a) the operation with smart contracts whose data possess a complex structure and (b) the efficient execution of elaborate queries on these data. By using DELTA, query times decrease, at least, between one and five orders of magnitude, depending on the DLT, compared to queries directed to the ledger nodes.

The CAP theorem states that only two of these properties can be simultaneously guaranteed in a distributed service: (i) consistency, (ii) availability and (iii) network partition tolerance. This theorem was stated and proved assuming that ‘consistency’ refers to atomic consistency. However, multiple consistency models exist and atomic consistency is located at the strongest edge of that spectrum. Many distributed services deployed in cloud platforms should be highly available and scalable. Network partitions may arise in those deployments and should be tolerated. One way of dealing with CAP constraints consists in relaxing consistency. Therefore, it is interesting to explore the set of consistency models not supported in an available and partition-tolerant service (CAP-constrained models). Other weaker consistency models could be maintained when scalable services are deployed in partitionable systems (CAP-free models). Three contributions arise: (i) multiple other CAP-constrained models are identified, (ii) a borderline between CAP-constrained and CAP-free models is set and (iii) a hierarchy of consistency models depending on their strength and convergence is built.

In this paper, we provide preliminary results on the emerging problem of modeling and managing uncertainty in concurrent database transactions. This work thus completes several previous studies that, by the contrary, have not considered the specific case of concurrent transactions, which may worse the uncertainty of database management activities beyond to the simplest case of isolated transactions. Indeed, as we demonstrate in this paper, inconsistency tolerance of integrity management, constraint checking and repairing easily scales up to concurrent transactions in a natural way, and query answering in concurrent transactions over uncertain data remains certain in the presence of uncertainty

Common solutions to database replication use a single replication protocol. This approach lacks flexibility for changing scenarios or when dealing with heterogeneous client application requirements. Our proposal is a metaprotocol that supports several replication protocols which may follow different replication techniques or provide different isolation levels. With our metaprotocol, replication protocols can either work concurrently with the same data or be sequenced for adapting to dynamic environments. Experimental results demonstrate its low overhead and measure the influence of protocol concurrency on system performance.

Replication has been told to be a solution to provide scalability and high availability in databases. Unfortunately, the cost of ensuring isolated and consistent executions is sometimes too high. Weakest isolation models have proved to be a way to reduce this cost but they can violate some applications transactions isolation needs. In stand-alone systems, models supporting different isolation restrictions for concurrent transaction are used to avoid this dilemma. With this kind of protocols, applications can specify every transaction isolation requirements. However, how to extend these models to replicated systems is still an issue. In this paper we extend Adya's model based on serialization graphs as a first step to construct replication protocols with such a feature.

Replication is used for providing highly available and fault-tolerant information systems, which are constructed on top of replication and recovery protocols. Important aspects when designing these systems are the failure model assumed and the progress condition assumed. Replicated transactionalsystems usually assume the crash-recovery with partial amnesia failure model, and the majority partition progress condition. But, despite the large use of such combination most of these works do not handle accurately a very special phenomenon that can lead to diverging states in different replicas causing, when happening, critical situations.

Database replication protocols based on a certification approach are usually the best ones for achieving good performance. The weak voting approach achieves a slightly longer transaction completion time, but with a lower abortion rate. So, both techniques can be considered as the best ones for replication when performance is a must, and both of them take advantage of the properties provided by atomic broadcast. We propose a new database replication strategy that shares many characteristics with such previous strategies. It is also based on totally ordering the application of writesets, using only an unordered reliable broadcast, instead of an atomic broadcast. Additionally, the writesets of transactions that are aborted in the final validation phase are not broadcast in our strategy. Thus, this new approach reduces the communication traffic and also achieves a good transaction response time (even shorter than those previous strategies in some system configurations).

Group communication and atomic multicast (i.e., total order multicast) topics have been studied for more than two decades from both a theoretical and a practical point of view. Most of this work is concerned about the classical definition of total order (informally, all the messages are received in the same order). However, in some cases additional guarantees are needed, like priority-based delivery, which allows a user application to prioritize the sending and delivery of certain messages. In this paper, we present several techniques to modify an existing total order protocol to take into account message priorities and show how existing total order algorithms can be modified according to these techniques.

The virtually synchronous execution model provides anappropriate support for developing reliable applications when the crash failure model is being assumed. Using it, group broadcasts only need to be based on asynchronous communication. Synchronization points are set when a view change arises, guaranteeing an efficient execution of such reliable applications. But a crash failure model is not always appropriate for all applications. Indeed, those using persistent or large state, like replicated databases, need a recoverable model. In such cases, the virtual synchrony property needs to be partially extended for adequately supporting more intricate recovery protocols. Persistent logical synchrony is one variation of this kind, that extends the synchronization actions to be taken when aview change arises, allowing a good support for partial recovery when the primary component membership is being assumed.

In this work, we present the correctness criteria that ensures a replicated database behaves like a single copy where trans-actions see a weaker form of SI, called Generalized-SI, with deferred update protocols in a crash failure scenario.

Snapshot isolation has received a considerable amount of attention in the context of full database replication. Such popularity is mainly because read-only transactions executing under snapshot isolation are never blocked or aborted. In partial replication, where each replica holds only a part of the database, transactions may require access to remote databases. Each remote read operation of the transaction must execute in a consistent global database snapshot as the local operations; if such a snapshot is not available, the transaction must be aborted. In this paper we are interested in the effects of distributed transactions on the abort rate of partially replicated snapshot isolation systems. We present a simple probabilistic analysis of transaction abort rates for two different concurrency control mechanisms: lock- and version-based. The former models the behavior of a replication protocol providing one-copy-serializability; the latter models snapshot isolation. Our analysis reveals that in the version-based system the execution abort rate decreases exponentially as the number of data versions available increases. As a consequence, in all cases considered, two versions of each data item were sufficient to eliminate aborts due to distributed transactions.

Middleware database replication is a way to increase availability and afford site failures for dynamic content Websites. There are several replication protocols that ensure data consistency for these systems. The most attractive ones are those providing generalized snapshot isolation (GSI), as read operations never block. These replication protocols are based on the certification process, however, up to our knowledge, they do not cope with the recovery of a replica. In this paper we propose a recovery protocol that ensures GSI (we provide an outline of its correctness) that does not interfere with user transactions and permits the execution of transactions in the recovering node, even though the recovery process has not finished

The current standard for fault-tolerance in the Common Object Request Broker Architecture (CORBA) does not support network partitioning. However, distributed systems, and those deployed on wide area networks in particular, are susceptible to network partitions. The contribution of this paper is the description of the design and implementation of a CORBA fault-tolerance add-on for partitionable environments. Our solution can be applied to an off-the-shelf Object Request Broker, without having access to the ORB's source code and with minimal changes to existing CORBA applications. The system distinguishes itself from existing solutions in the way different replication and reconciliation strategies can be implemented easily. Furthermore, we provide a novel replication and reconciliation protocol that increases the availability of systems, by allowing operations in all partitions to continue

Passive replication has been extensively studied in the literature. However, there is no comprehensive study yet with regard to its degree of communication synchrony. Therefore, we propose a new, detailed classification of hot passive replication protocols, including a survey of the fault tolerance and performance of each class

Replicated systems are commonly used to provide highly available and fault tolerant applications, based on the use of replication and recovery protocols. Traditionally, the literature has focused on replicated systems which adopt the fail-stop failure model which presents good performance levels for replicated systems managing few state. This paper points out how the crash-recovery with partial amnesia failure model presents a better accuracy for replicated systems with huge state, but how its use has the amnesia phenomenon drawback. Then, the paper analyzes this phenomenon and how to deal with it in a basic configuration using a log-based recovery approach. Analyzing after, how it is supported and managed with other replication configurations.

Process replication is used for providing highly available and fault-tolerant systems. Traditionally, for simplicity reasons they have assumed the crash-stop failure model. This paper, instead, encourages the use of the crash-recovery with partial amnesia failure model when managing large state amounts, presenting the arising problems of this assumption and outlining how they can be managed. Finally, an overhead analysis is presented.

Certification-based database replication protocols are a good basis to develop replica recovery when they provide the snapshot isolation level. For such isolation level, no readset needs to be transferred between replicas nor checked in the certification phase. Additionally, these protocols need to maintain a historic list of writesets that is used for certifying the transactions that arrive to the commit phase. Such historic list can be used to transfer the missed state of a recovering replica. We study the performance of the basic recovery approach - to transfer all missed writesets - and a version-based optimization - to transfer the latest version of each missed item, compacting thus the writeset list - and the results show that such optimization reduces a lot the recovery time.

Mobile databases are a centerpiece of the dramatic growth of data-centric applications for mobile computing, nomadic communication and wireless networks. Replication of database content is useful in client-server and peer- to-peer configurations of mobile distributed databases. We present an adaptation of generalized snapshot isolation for transactions on content data in mobile networks. This solution overcomes various limitations of known approaches to manage mobile database transactions.

Distributed object systems for partitionable systems present a challenge, in that there is a trade-off between availability and consistency. Changes in one partition are not visible in another partition. Therefore, if strong consistency is required, certain operations cannot be permitted. This reduces availability. In the DeDiSys project we aim at allowing this trade-off between consistency and availability to be configurable. The DeDiSys distributed object system relies heavily on replication protocols that allow high-availability, whilst ensuring a level of consistency that is required by a particular application. We have developed DeDiSys Lite, a prototype of the DeDiSys system, which provides a platform to implement and evaluate these replication protocols. Infrastructure components are provided in a minimal implementation. Configuration files allow system parameters, such as the degree of replication or the nesting of object invocations, to be modified, without having to adapt application code. We use DeDiSys Lite as both a simulation environment for the development of new replication protocols and as a basis for the continuous development of the DeDiSys system. Some results obtained using the platform to optimise a new replication protocol are presented in this paper.

We present a system architecture which facilitates enhanced availability of tightly coupled distributed systems by temporarily relaxing constraint consistency. Three different types of consistency are distinguished in tightly coupled distributed systems - replica consistency, concurrency consistency, and constraint consistency. Constraint consistency defines the correctness of the system with respect to a set of data integrity rules (application defined predicates). Traditional systems either guarantee strong constraint consistency or no constraint consistency at all. However, a class of systems exists, where data integrity can be temporarily relaxed in order to enhance availability, i.e. constraint consistency can be traded against availability. This allows for a context- and situation-specific optimum of availability. This paper presents the basic concepts of the trading process and the proposed system architecture to enable a fine-grained tuning of the trade-off in tightly coupled distributed systems.

Middleware database replication techniques is a way to increase performance and fault tolerance without modifying the database management system (DBMS) internals. However, it introduces an additional overhead that may lead to poor response times. In this paper we present a modification of the optimistic two phase locking (O2PL) M.J. Carey et al. (1991) protocol that orders transactions by way of a deadlock prevention schema, instead of using the total order transaction delivery obtained by group communication systems (GCSs) G. Chockler et al. (2001) techniques, and do not need the 2 phase commit (2PC) rule P.A. Bernstein et al. (1987). We formalize its definition as a state transition system and show that it is 1-copy-serializable (1CS) P.A. Bernstein et al. (1987).

Database replication protocols need to detect, block or abort part of conflicting transactions. A possible solution is to check their writesets (and also their readsets in case a serialisable isolation level is requested), which however burdens the consumption of CPU time. This gets even worse when the replication support is provided by a middleware, since there is no direct DBMS support in that layer. We propose and discuss the use of the concurrency control support of the local DBMS for detecting conflicts between local transactions and writesets of remote transactions. This allows to simplify many database replication protocols and to enhance their performance

The reliable object invocation mechanism provided by HIDRA for the coordinator-cohort and the passive replication models offers support to ensure that all the replicas of the object being invoked are correctly updated before such an invocation is terminated. This mechanism also ensures that if a primary or coordinator replica crashes, the client is able to reconnect to the previously initiated invocations, collecting their results without requiring their reexecution. All this support is provided transparently to the client of the replicated objects, which does not notice any difference in respect to the invocations made to non-replicated objects. Moreover, the protocols described in the paper deal also with the failure of any of the objects involved in this kind of invocations.