Abstract:
Methods and systems are disclosed for detecting data divergence or inconsistency across replicas of data maintained in replica nodes in a shared-nothing distributed computer database system. The replica nodes communicate with a coordinator node over a computer network. The method includes the steps of: (a) receiving an operation at the coordinator node; (b) transmitting the operation to the replica nodes to be executed by each replica node to generate an operation result and a hash representation of the operation or of the operation result; (c) receiving the operation result and the hash representation generated by each of the replica nodes; and (d) determining whether the operation resulted in data divergence or inconsistency by detecting when the hash representations received from the replica nodes are not all the same.

Description:
CROSS REFERENCE TO RELATED APPLICATION 
       [0001]    This application claims priority from U.S. Provisional Patent Application No. 61/875,283 filed on Sep. 9, 2013 entitled METHODS AND SYSTEMS FOR DETECTING DATA DIVERGENCE AND INCONSISTENCY ACROSS REPLICAS OF DATA WITHIN A SHARED-NOTHING DISTRIBUTED DATABASE, which is hereby incorporated by reference. 
     
    
     BACKGROUND 
       [0002]    The present application relates generally to computer database systems and, more particularly, to methods and systems for detecting data divergence and inconsistency across replicas of data within a shared-nothing distributed database. 
       BRIEF SUMMARY OF THE DISCLOSURE 
       [0003]    In accordance with one or more embodiments, a method is provided for detecting data divergence or inconsistency across replicas of data maintained in replica nodes in a shared-nothing distributed computer database system. The replica nodes communicate with a coordinator node over a computer network. The method includes the steps of: (a) receiving an operation at the coordinator node; (b) transmitting the operation to the replica nodes to be executed by each replica node to generate an operation result and a hash representation of the operation or of the operation result; (c) receiving the operation result and the hash representation generated by each of the replica nodes; and (d) determining whether the operation resulted in data divergence or inconsistency by detecting when the hash representations received from the replica nodes are not all the same. 
         [0004]    In accordance with one or more further embodiments, a coordinator node is provided in a shared-nothing distributed computer database system. The coordinator node communicates with a plurality of replica nodes over a computer network. The coordinator node includes at least one processor, memory associated with the at least one processor, and a program supported in the memory for detecting data divergence or inconsistency across replicas of data maintained in the replica nodes. The program contains a plurality of instructions which, when executed by the at least one processor, cause the at least one processor to: (a) receive an operation at the coordinator node; (b) transmit the operation to the plurality of replica nodes to be executed by each replica node to generate an operation result and a hash representation of the operation or of the operation result; (c) receive the operation result and the hash representation generated by each of the replica nodes; and (d) determine whether the operation resulted in data divergence or inconsistency by detecting when the hash representations received from the plurality of replica nodes are not all the same. 
         [0005]    In accordance with one or more further embodiments, a computer program product is provided for detecting data divergence or inconsistency across replicas of data maintained in replica nodes in a shared-nothing distributed computer database system. The replica nodes communicate with a coordinator node over a computer network. The computer program product residing on a non-transitory computer readable medium having a plurality of instructions stored thereon which, when executed by a computer processor, cause that computer processor to: (a) receive an operation at the coordinator node; (b) transmit the operation to the plurality of replica nodes to be executed by each replica node to generate an operation result and a hash representation of the operation or of the operation result; (c) receive the operation result and the hash representation generated by each of the replica nodes; and (d)determine whether the operation resulted in data divergence or inconsistency by detecting when the hash representations received from the plurality of replica nodes are not all the same. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0006]      FIG. 1  is a simplified diagram illustrating an exemplary shared-nothing database system in accordance with one or more embodiments. 
           [0007]      FIG. 2  is a simplified diagram illustrating operation of an exemplary Transaction 
           [0008]    Coordinator in accordance with one or more embodiments. 
           [0009]      FIG. 3  is a simplified diagram illustrating an exemplary Transaction Coordinator receiving an incoming transaction in accordance with one or more embodiments. 
           [0010]      FIG. 4  is a simplified diagram illustrating delivery of incoming transactions to replica nodes in accordance with one or more embodiments. 
           [0011]      FIG. 5  is a simplified diagram illustrating execution of an exemplary transaction by the Transaction Execution Engine of a replica node in accordance with one or more embodiments. 
           [0012]      FIG. 6  is a simplified diagram illustrating transmission of exemplary transaction results to the Transaction Coordinator in accordance with one or more embodiments. 
       
    
    
     DETAILED DESCRIPTION 
       [0013]    In a shared-nothing distributed database, high availability is maintained in the face of node failure by maintaining replicas of the data across different nodes of a distributed database cluster. In this manner, a replica on a failing node can be lost, but a complete set of data still exists on another replica node. Having access to a complete set of data allows the database to return consistent, correct, and complete answers. 
         [0014]    In order to return consistent, correct, and complete answers in the event of replica node failure, all replicas must be kept identical at all times. This is required because the same transaction or operation executed on each replica at the same time must return the same results. 
         [0015]    In the exemplary embodiments illustrated herein, the shared-nothing distributed database system processes transactions as managed by a Transaction Coordinator. It should be understood that this is by way of example only and that the embodiments are equally applicable to the processing of operations generally in a shared-nothing distributed database system as managed by an operations coordinator. 
         [0016]      FIG. 1  schematically illustrates one example of a shared-nothing database system  10  in accordance with one or more embodiments. The shared-nothing database system maintains replicas of data across a plurality of replica nodes  12  of a distributed database cluster. The replica nodes are connected to a Transaction Coordinator node  14  through a computer network  16 . The nodes are physically separated or isolated from one another. In one or more embodiments, each node comprises a computer system having its own processing, memory, and disk resources. Specifically, each node includes a central processing unit (CPU)  18 , random access memory (RAM)  20 , and disk memory  22 . The techniques described herein may be implemented in one or more computer programs executing on the CPU associated with each node. Each replica node for instance includes a Transaction Execution Engine executing on its CPU as described below. 
         [0017]    The system&#39;s synchronous intra-cluster replication requires that performing the same operations in the same order on the same state in different replicas will result in identical replicas at all times. In other words, the data must be consistent and identical in every replica instance. 
         [0018]    The system executes transactions serially in each replica. There can be two or more replica copies of the data within the database, each containing identical transactional data. The system makes sure that each replica executes transactions in the same order. The system is configured such that that if the same operations are performed in the same order to the same original data (state), the resulting data (state) will be the same. For synchronous intra-cluster replication, the Transaction Coordinator makes sure that each transaction is executed successfully at each replica before the operation is committed and success is returned to the caller. Likewise, if a transaction fails at one replica, the Transaction Coordinator assumes it will fail at all replicas. 
         [0019]    Since there is no inter-replica communication during an operation, the transaction operations themselves must be deterministic. If they are not, divergence can occur. For example, if one replica transaction operation inserts a randomly generated number and the same transaction operation in a different replica generates and inserts a different random number, then the replicas will have diverged. Future operations on the replicas can and will return different results. 
         [0020]    Consider a transaction that operates on a bank account. The balance and transaction timestamp (timestamp is passed to the transaction as a parameter) must be the same across all copies of this data. Table 1 below illustrates a simple example of a transaction containing multiple operations that runs identically across all replicas of the data: 
         [0000]    
       
         
               
             
               
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 Deterministic Transaction across all Replicas 
               
             
          
           
               
                   
                 OPERATION 
                 RESULT 
               
               
                   
                   
               
               
                   
                 Set balance = $100 
                 Balance = $100 
               
               
                   
                 Deduct $20 from balance 
                 Balance = $80 
               
               
                   
                 Set transaction time to Param1 
                 Transaction time = Param1value 
               
               
                   
                 Return Balance 
                 Balance = $80 
               
               
                   
                   
               
             
          
         
       
     
         [0021]    Consider the transaction in Table 2 below, which executes similar operations on a bank account but rather than passing in a transaction timestamp, it computes the timestamp. In this transaction the timestamp will very likely be different in each replica due to the fact that it is nearly impossible that the time would be computed exactly the same on different machines (or even different process spaces on the same machine): 
         [0000]    
       
         
               
             
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 Non-Deterministic Transaction between all Replicas 
               
             
          
           
               
                 OPERATION 
                 RESULT 
               
               
                   
               
               
                 Set balance = $100 
                 Balance = $100 
               
               
                 Deduct $20 from balance 
                 Balance = $80 
               
               
                 Set date of operation to local 
                 Date computed in local machine (can be 
               
               
                 computation of NOW( ) 
                 different on each machine!) 
               
               
                 Return Balance 
                 Balance = $80 
               
               
                   
               
             
          
         
       
     
         [0022]    Differing data across replicas results in inconsistent data—leaving open to question which data to trust. For example, perhaps a customer gets one free bank withdrawal per day, and since the timestamp is different, a withdrawal around midnight might count towards different days at different replicas. For this reason, it is critically important that copies of data be kept completely consistent and match all other copies. Yet there is the possibility that user-created transactions could introduce differences. In addition to the timestamp computation identified in Table 2, additional opportunities present themselves in the form of pseudo-random number generation. 
         [0023]    The database system in accordance with one or more embodiments ensures that replicas do not diverge and does so with minimal communication overhead in order to maintain target throughput rates. To do this, the system maintains a running hash of the logical work done in each transaction at each replica. When the transaction logic is about to execute a sub-operation that may modify state, such as an SQL-DML (structured query language-data manipulation language) operation, a representation of the operation (this could be, but is not limited to, the SQL text defining the operation) and any applicable parameters or modifiers are added to the running hash. The cumulative running hash is returned to the Transaction Coordinator with the results of the full operation (transaction) at each replica. The logical unit that coordinates replication (the Transaction Coordinator) compares the hashes and can immediately detect if any sub-operation was different at different replicas, meaning the state may have diverged. At this point, appropriate action may be taken, such as repairing the state, rejecting all-but-one replica, or shutting down the database. 
         [0024]    Note that this requires that sub-operations with identical representations be deterministic. The system has carefully ensured its operations, which could be SQL-DML, are always deterministic, given the same operations (SQL commands) and parameter values. 
         [0025]    The benefits of this processing may include the following:
       1. Data divergence is computed against distributed state.   2. Does not require n̂2 (n squared) communication between replicas.   3. Does not require blocking communication between replicas.   4. This method identifies the transaction, as well as the operation within the transaction, that introduced replica divergence.   5. The operation is computationally fast and space efficient.       
 
         [0031]    The steps in a process in accordance with one or more embodiments are as follows:
       1. The Transaction Coordinator receives a transaction as shown in  FIG. 3 . By way of simple example, the incoming transaction could contain the operation in Table 3.       
 
         [0000]    
       
         
               
             
           
               
                 TABLE 3 
               
               
                   
               
               
                 Exemplary Transaction 
               
               
                 TRANSACTION 
               
               
                   
               
             
             
               
                 Set balance = $100 
               
               
                 Deduct $20 from balance 
               
               
                 Set date of operation to local computation of NOW( ) 
               
               
                 Return Balance 
               
               
                   
               
             
          
         
       
       
         
           
             2. The Transaction Coordinator delivers the transaction to the Transaction Execution Engine of every participating replica and replica copy as shown in  FIG. 4 . Note that each replica copy contains the exact same data as its corresponding replica(s). 
             3. Each participating replica&#39;s Transaction Execution Engine executes the transaction as shown in  FIG. 5 . The transaction may comprise one or more operations to execute. The transaction may also have parameters that are fed to the operations. 
             4. The Transaction Execution Engine maintains a set of Hash values. When the transaction logic is about to execute a sub-operation that may modify state, such as SQL-DML, a hash representation of the operation (this could be, but is not limited to, the SQL text defining the operations) and any applicable parameters or modifiers are added to the running hash set or value as shown in the example of Table 4. 
           
         
       
     
         [0000]    
       
         
               
             
               
               
               
             
           
               
                 TABLE 4 
               
             
             
               
                   
               
               
                 Transaction Operation Hashes Computed 
               
             
          
           
               
                 OPERATION 
                 OPERATION RESULT 
                 RESULT HASH 
               
               
                   
               
               
                 Set balance = $100 
                 Balance = $100 
                 &lt;Computed hash #1&gt; 
               
               
                 Deduct $20 from balance 
                 Balance = $80 
                 &lt;Computed hash #2&gt; 
               
               
                 Set date of operation to local 
                 Date computed in local 
                 &lt;Computed hash #3&gt; 
               
               
                 computation of NOW( ) 
                 machine (can be different  
                   
               
               
                   
                 on each machine!) 
                   
               
               
                 Return Balance 
                 Balance = $80 
                 &lt;Cumulative hash&gt; 
               
               
                   
               
             
          
         
       
       
         
           
             5. The transaction result, as well as the resulting hash value and set from each replica is returned to the coordinating Transaction Coordinator as shown in  FIG. 6  and in Table 5 below. 
           
         
       
     
         [0000]    
       
         
               
             
               
               
               
             
           
               
                 TABLE 5 
               
             
             
               
                   
               
               
                 Transaction Result to Return 
               
             
          
           
               
                   
                 TRANSACTION RESULT 
                 TRANSACTION HASH RESULT 
               
               
                   
                   
               
               
                   
                 Balance = $80 
                 &lt;Computed hash #1&gt; 
               
               
                   
                   
                 &lt;Computed hash #2&gt; 
               
               
                   
                   
                 &lt;Computed hash #3&gt; 
               
               
                   
                   
                 &lt;Cumulative hash&gt; 
               
               
                   
                   
               
             
          
         
       
       
         
           
             6. The coordinating Transaction Coordinator compares the cumulative hashes from each participating replica. If the all the hash values are equal, the transaction ran identically and resulted in identical data and answers in each replica. If there is a difference in the hashes, then replicas have diverged; they are no longer exact copies of each other. An inconsistent system now exists and must be rectified. At this point, appropriate action may be taken such as, e.g., repairing the state, rejecting all-but-one replica, or shutting down the database. 
           
         
       
     
         [0000]    
       
         
               
             
               
               
               
             
           
               
                 TABLE 6 
               
             
             
               
                   
               
               
                 Replica R1 Result 
               
             
          
           
               
                   
                 TRANSACTION RESULT 
                 TRANSACTION HASH RESULT 
               
               
                   
                   
               
               
                   
                 Balance = $80 
                 &lt;Computed hash #1&gt; = 123 
               
               
                   
                   
                 &lt;Computed hash #2&gt; = 456 
               
               
                   
                   
                 &lt;Computed hash #3&gt; = 789 
               
               
                   
                   
                 &lt;Cumulative hash&gt; = 1368 
               
               
                   
                   
               
             
          
         
       
     
         [0000]    
       
         
               
             
               
               
               
             
           
               
                 TABLE 7 
               
             
             
               
                   
               
               
                 Replica R1′ Result 
               
             
          
           
               
                   
                 TRANSACTION RESULT 
                 TRANSACTION HASH RESULT 
               
               
                   
                   
               
               
                   
                 Balance = $80 
                 &lt;Computed hash #1&gt; = 123 
               
               
                   
                   
                 &lt;Computed hash #2&gt; = 456 
               
               
                   
                   
                 &lt;Computed hash #3&gt; = 913 
               
               
                   
                   
                 &lt;Cumulative hash&gt; = 1492 
               
               
                   
                   
               
             
          
         
       
     
         [0038]    The Transaction Coordinator compares the cumulative hashes between all participating replica results. In the example illustrated in Tables 6 and 7, the hash sum of 1368 returned by Replica R1 does not equal 1492, which was the result of the transaction returned by Replica R1′. This indicates that the transaction caused diverging replica data. 
         [0039]    In accordance with one or more embodiments, the method could be further extended to track the exact operation that introduced this divergence (operation #3 in this example) by maintaining a list of hashes matched to each operation of the transaction. Comparing lists from multiple partitions can quickly identify the operation that introduced an inconsistency, the non-deterministic result. 
         [0040]    In accordance with one or more embodiments, a variation to the method for detecting divergence may be used in place of or in addition to the methods described above. Rather than building a hash of representations of a sequence of operations, a running hash is created by hashing individual modified data. For some operations like inserting data into a database and replacing a single value, the logical operation and the changed data are identical. However, for more complex operations, such as those possible with SQL and other query languages, the logical operation and the modified data are different. For example, the logical operation “Make the data stored at X equal to X squared” is different from “value 5 changed to 25.” As another example, “give everyone in Dept. B a 5% raise” is different from the resulting list of old and new salaries. This second example illustrates the key difference between hashing the logical operation and hashing the mutated data. Sometimes the logical operation is larger, and sometimes the mutated data is larger. The methods are essentially isomorphic in utility, though which method is more efficient usually depends on the workload. 
         [0041]    The processes of the shared-nothing database system described above may be implemented in software, hardware, firmware, or any combination thereof. The processes are preferably implemented in one or more computer programs executing on the nodes, which each include at least one processor, a storage medium readable by the processor (including, e.g., volatile and non-volatile memory and/or storage elements), and input and output devices. Each computer program can be a set of instructions (program code) in a code module resident in the random access memory of the node. Until required by the node, the set of instructions may be stored in another computer memory (e.g., in a hard disk drive, or in a removable memory such as an optical disk, external hard drive, memory card, or flash drive) or stored on another computer system and downloaded via the Internet or other network. 
         [0042]    Having thus described several illustrative embodiments, it is to be appreciated that various alterations, modifications, and improvements will readily occur to those skilled in the art. Such alterations, modifications, and improvements are intended to form a part of this disclosure, and are intended to be within the spirit and scope of this disclosure. While some examples presented herein involve specific combinations of functions or structural elements, it should be understood that those functions and elements may be combined in other ways according to the present disclosure to accomplish the same or different objectives. In particular, acts, elements, and features discussed in connection with one embodiment are not intended to be excluded from similar or other roles in other embodiments. Additionally, elements and components described herein may be further divided into additional components or joined together to form fewer components for performing the same functions. Accordingly, the foregoing description and attached drawings are by way of example only, and are not intended to be limiting.