Replay recovery protocol for real-time database management systems
STATEMENT OF GOVERNMENT INTEREST 
     The invention described herein may be manufactured and used by or for the Government of the United States of America for governmental purposes without the payment of any royalties thereon or therefor. 
    
    
     CROSS REFERENCE TO RELATED PATENT APPLICATIONS 
     This patent application is co-pending with four related patent applications entitled Early Commit Locking Computer Database Protocol, U.S. Ser. No. 08/238,045, now pending; Early Commit Timestamp Computer Database Protocol, U.S. Ser. No. 08/238,033, now pending; Early Commit Optimistic Computer Database Protocol, U.S. Ser. No. 08/238,036, now pending; and Merge, Commit Recovery Protocol for Real-Time Database Management Systems, U.S. Ser. No. 08/236,900, now pending all by the same inventor and filed on the same date as subject patent application. 
     BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to real-time database systems and more particularly to a real-time computer database method which provides increased availability of data to multiple transactions while maintaining database consistency in the event of a system failure. 
     2. Description of the Prior Art 
     It is well known that database systems fail for a variety of reasons. The computer hardware can fail, the storage media can fail, or the transaction processing software can fail. System failures cause loss of volatile main memory storage, transaction failures cause an abnormal termination of a transaction, and media failures cause a loss of secondary nonvolatile storage. 
     Failure recovery must ensure that the database remains consistent after one of these failures. Redundant media storage and shadowing the database across the redundant media allows recovery if one set of the media fails. Shadowing the data requires changes to be written to both copies of the database without interruption. On failure, the shadow database becomes the primary database, and the database system can continue to operate. Of more interest are system and transaction errors because these errors are expected more frequently, and recovery from these errors must be efficiently supported. A typical transaction error called &#34;deadlock&#34; occurs when two transactions are waiting on each other to complete usage of a particular data set, and each transaction has locked the data needed by the other. The usual solution to this error is to abort one of the two conflicting transactions and then restart the transaction. 
     When a hardware or power failure occurs, information contained in primary memory such as random access memory (RAM) is considered lost. With this type of failure, transactions are left in one of two states; those committed before the failure, and those active but not committed before the failure. Committed transactions are those transactions which have been copied from the primary memory to a stable computer database media such as a magnetic disk, optical disk, or magnetic tape. Recovery must ensure that committed transactions remain committed and active transactions do not cause database inconsistencies upon reactivation. 
     Conventional means for recovery of committed and active transactions use non-volatile checkpointing to mark data items which have been committed. Upon recovery from the system error, check pointed transactions are completed to make permanent the changes specified by those transactions. Any database changes made by the uncommitted transactions are restored to the state which existed before the transaction was performed. Undone transactions can be restarted at some later time. Some disadvantages of this system are that it requires the maintenance of a log for all database operations for use in restoring a database in some previous state. During recovery, the system applies the log to the entire transaction requiring the entire transaction to be undone or redone, and during recovery the database is unavailable for use. 
     SUMMARY OF THE INVENTION 
     Accordingly, it is a general purpose and object of the present invention to provide a real-time database system that maintains database consistency and correctness when a failure occurs. 
     Another object of the database system is that it provide concurrent access to data items to multiple transactions. 
     It is a further object that such database system provide recovery from system and transaction failures in a timely manner. 
     These objects are accomplished with the present invention by providing a computer database method using data organized into atomic data sets and transactions separated into projections having statements which operate on only one atomic data set. Statements such as read commands, write commands, assignment commands, transaction delimiting commands, and projection delimiting commands are executed, and a depends on graph is created during execution of the statements. Projection recovery data is stored during operation. When a statement requests commit the depends on graph is analyzed to determine if the projection is related to another projection in the transaction. The projection is committed if it is not related to another projection and delayed if related to another projection. Likewise, related projections are determined and aborted together if a transaction error occurs. The method allows recover to a consistent database state after projection abortion while preserving concurrency and availability during operation. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     A more complete understanding of the invention and many of the attendant advantages thereto will be readily appreciated as the same becomes better understood by reference to the following detailed description when considered in conjunction with the accompanying drawings wherein: 
     FIG. 1 shows pseudocode for an example transaction; 
     FIGS. 2a-2c show a steps in the creation of a depends on graph for the transaction of FIG. 1; 
     FIG. 3 shows an implementation of atomic data sets as used by the invention; 
     FIG. 4 shows an implementation of recovery block table used by the invention to recovery from errors; 
     FIG. 5 shows an implementation of a variable lock table used by the invention to preserve database consistency and maintain the depends on graph; and 
     FIG. 6 shows a flow chart of the replay recovery process of the current invention. 
    
    
     DESCRIPTION OF THE PREFERRED EMBODIMENT 
     As used in this disclosure the term &#34;transaction&#34; refers to a series of statements including reads, writes, and assignments that act on a database. An atomic data set (ADS) is a portion of a database which is partitioned into the smallest set of data in which consistency can be maintained. The database is broken up into ADSs based upon constraint definitions at the time the database is built. The term &#34;projection&#34; refers to a subsequence of statements from a particular transaction that access a particular ADS. A statement is in a particular projection if that statement from the transaction reads or writes data from or to the particular ADS. An assignment statement is not in any projection because it does not read or write data. A second statement is said to depend on a first statement if the second statement uses data that is defined in the first statement or in any intervening statements that are directly or indirectly dependent on data from the first statement. 
     EXAMPLE 1 
     Let T be a transaction with statements S 0 , S 1 , S 2 , S 3 , S 4 , and S 5 . 
     
         ______________________________________                                    
S.sub.0 :v.sub.1 : = r(x)                                                 
             /*S.sub.0 defines v.sub.1 using data item x */               
S.sub.1 :v.sub.2 : = r(y)                                                 
             /*S.sub.1 defines v.sub.2 using data item y */               
S.sub.2 :v.sub.3 : = f(v.sub.1)                                           
             /*S.sub.2 defines v.sub.3 using v.sub.1 */                   
S.sub.3 :v.sub.4 : = f(v.sub.2)                                           
             /*S.sub.3 defines v.sub.4 using v.sub.2 */                   
S.sub.4 :v.sub.5 : = f(v.sub.4)                                           
             /*S.sub.4 defines v.sub.5 using v.sub.4 */                   
S.sub.5 :w(y, v.sub.4)                                                    
             /*S.sub.5 redefines data item y using v.sub.4                
______________________________________                                    
             */                                                           
 
    
     S 2  directly depends on S 0  because S 2  uses v 1  from S 0  to define v 3 . S 3  directly depends on S 1  because S 3  uses v 2  from S 1  to define v 4 . S 4  directly depends on S 3  because S 4  uses v 4  from S 3  to define v 5 , and S 4  depends on S 1  because S 4  uses v 4  from S 3 , which was defined using v 2  defined in S 1 . If x and y belong to distinct atomic data sets A and B respectively then S 0  is in a projection π A  and S 1 , S 5  are in a projection π B . 
     Projections also exhibit dependency. If one statement in a first projection is dependent on data from a second projection then the first projection depends on the second projection. Projections are related if a dependency exists among two or more of them. 
     A depends-on graph can be constructed during transaction run time using the projections as nodes and the dependency relationships between projections as edges. When a projection begins, a node for that projection is inserted in the depends on graph. When the projection executes a read statement a definition lock is placed on the result memory variable of the read statement. Execution of an assignment statement causes no change to the depends on graph; however, its operation must be considered because assignment statements can have transitive effects. A write statement causes a use lock to be placed on the result memory variable of the statement. Placing a definition lock on a variable causes the system to generate an edge between the projection&#39;s node and other projection&#39;s nodes which hold either a use lock or a definition lock on the variable. Placement of a use lock on a variable causes the system to generate an edge between the projection placing the use lock and any other projections which hold definition locks on that variable. 
     When a projection requests commit, the system looks at the generated depends on graph. If any edges exist between the projection committing and another projection then the projections are related. Commit for the projection requesting commit must delay until all related projections have requested commit to ensure system consistency. 
     Referring now to FIG. 1 there is shown pseudocode for a transaction in which one projection depends on another projection. In this figure, &#34;Tbegin&#34; indicates the start of the transaction and &#34;Tend&#34; indicates the end of the transaction projection. Hereinafter, &#34;Tbegin&#34; and &#34;Tend&#34; are referred to collectively as transaction delimiting commands. Projection A is referred to using the symbol π A , and projection B is referred to by π B . The beginning of a projection is indicated by sb(X) where X is the particular projection. Likewise, the commit time for a projection is indicated by sc(X) where X is the particular projection. Collectively, the commands sb(X) and sc(X) are known as projection delimiting commands. The projection delimiting statements, sb(X) and sc(X), are coded by an applications programmer or applications programming system. The programmer places the statement sc(X) to assure that preceding data is properly updated but also available to other concurrent transactions at an early time. Reading a variable from a database is indicated by the function r(x) where x is the database variable being read. Writing a particular variable from a database is indicated by the command w(x,y) where x is the variable being written to and y is the memory variable being written to the database. Each statement of the transaction is indicated with the notation S x  where x is the number of the statement. In this example, database variables are referred to by the letters a, b, c, d, and e. Memory variables are referred to by v x  where x is a number. Symbolic comments are delimited by &#34;/*&#34; and &#34;*/&#34;. The transaction preserves a record of committed projections, and the current program counter position in stable storage. This information allows the transaction to begin after the last completed projection on an error. 
     As the system executes the statements contained in FIG. 1, a depends on graph is created as shown in FIGS. 2a-2c. In the transaction of FIG. 1, ADS A contains database variables a, b, and c, and ADS B contains database variables d and e. At S 1  projection A, π A , is started, and a node 10 is created for π A  in the depends on graph shown in FIG. 2a. S 2  reads a into memory variable v 1 . This has no affect on the depends on graph because a is a variable from π A  and v 1  has not been used or defined by another projection. Likewise, S 3  -S 5  have no affect on the depends on graph because they have not been used or defined by another projection. S 6  starts projection π B , and a new node 12 is inserted in the depends on graph as shown in FIG. 2b. S 7  reads d into memory variable v 4 . This action has no affect on the depends on graph because v 4  has not been defined or used by another projection. S 8  causes an edge 14 to be inserted into the depends on graph between node π A  10 and node π B  12 because v 4  is reassigned using v 3  a variable which has been used in π A . At S 9  projection π A  requests commit. The system examines the depends on graph shown in FIG. 2c to determine if π A  depends on any other projections. In this case, π A  would be allowed to commit because no other projections are dependent upon it. However, π B  is related to π A  because edge 14 exists between node π A  10 and node π B  12; therefore, π A  must commit before π B  can commit. In S 11 , projection π B  requests commit, and no delay occurs because π A  has committed. If π B  had requested commit before π A  then commit for π B  would have been delayed until after π A  &#39;s commit. After a transaction commits, its node and related edges are removed from the depends on graph. 
     Referring now to FIG. 3, there is shown a diagram of a typical database for use with the replay recovery protocol of this invention. The database shown is the database of FIG. 1 after the execution of S 7 . Two atomic data sets are shown as ADS A 30 and ADS B 32. These are representations of the stable data storage area that will not be affected by a transaction or system failure. While a projection is being executed, each subject ADS has two indexes, a main index 34 and a copy index 36. These two indexes provide a reference table give the system the location of each specific data item in the ADS. At the start of a projection the system allocates copy index area 34 and copies index information from main index 34 to copy index 36. The location of the main index is maintained by the system in stable storage. Both indexes, therefore, contain the same index information. While the projection is active, a write command to the ADS causes the system to write data items to a clear area of the ADS, and the system changes copy index 36 to refer to the newly written data. This is shown by example in FIG. 3 wherein a new value 38 has been written to data item c in ADS A 30. Copy index 36 for ADS A 30 points to the new value for data item c 38, and main index 34 continues to reference the previously committed value for c 40. Upon commit the system changes an index pointer 42 to refer to copy index 36 as the main index. Space formerly taken by main index 34 can be released. ADS B 32 shows a database wherein the data items have not been changed. In an alternative embodiment, index information could be copied from the copy index to the main index; however, the use of a pointer is more efficient in most applications. This database structure is known in the art, but is included herein for reference purposes. 
     A possible actual implementation for the database system is set forth in FIG. 4 and FIG. 5. Upon start of a transaction, the system allocates a recovery block table as shown in FIG. 4. When a projection begins as in S 1  of FIG. 1 a recovery block 40 is created with the program counter for the projection, π A  (pc) 42; the location of the projection&#39;s main index 44; the location of active variables at the start of the projection 46; and other projections which are active at the projection start 48. 
     When a transaction is first started the system also allocates a variable lock table for that transaction as in FIG. 5. Lock tables are well known in the database art to avoid referencing data that is currently in use. For example, if one transaction reads data that a first transaction is in the process of updating, the data read is most likely going to be in error until the first transaction has completed its update. Lock tables provide a means for keeping data from being read while it is being updated. In the inventive database system, the lock table for a particular transaction is preserved only for the duration of that transaction. Locks stored in the lock table identify the projection or transaction obtaining the lock, the type of lock being obtained, and point to related locks, if any. When a lock is placed on a variable, the lock contains at least one pointer referring to previous locks placed on that variable and related locks placed on other variables. Lock tables are typically implemented in computer software by flags and a linked list of pointers, although other well known methods can be used. 
     In the variable lock table of this invention, three types of locks can be placed on a variable. A use lock is placed on a variable when the variable is assigned. The symbolic syntax used herein for a use lock is U L  (X) where X is the transaction or projection acquiring the use lock. A definition lock is placed on a variable when that variable is defined. The syntax for a definition lock is D L  (X) where X is the projection acquiring the definition lock. A third type of lock, the inferred definition lock, is to allow the system to find possible definition conflicts without conducting a complete search of the lock table. For example, if a variable I is defined by a function of a variable J which was read from ADS X, the inferred definition lock should refer to ADS X. An inferred definition lock is indicated by the symbol inf D L  (last(v)) where last(v) is used to indicate the identifier for the last projection having a lock on variable v. To evaluate last(v) the system references the lock table for the specified variable v, and determines which projection last locked the variable. If locks were placed on the variable by multiple projections during the last operation on that variable, then last(v) will be result in multiple references. Inferred definition locks are created during assignment statements. When an assignment statement executes, the transaction acquires use locks, U L  (T), on the arguments of the assignment. The last projection used by the result variable and the last projections used by the argument variables acquire inferred definition locks, inf D L  (last(v)), on the result variable. Links are added from the use locks to the inferred definition locks set by the system on the arguments. These links allow the system to trace an assignment back to previous variables to determine if a dependency is caused by transitivity. 
     A read statement, v 1  :=r(a), such as S 2  in FIG. 1 causes the following lock table actions. The system inserts v 1  &#39;s identifier in the lock table if v 1  is not already in the lock table. Variable v 1  has a definition lock, D L  (π A ) placed on it from projection π A  because data is being read from that projection. 
     An assignment statement, v 3  :=f i  (v 1 , v 2 ) in S 4 , causes the system to insert v 3  &#39;s identifier in the lock table if it is not already there. The transaction, T, acquires use locks, U L  (T), on each of the arguments of the assignment, v 1  and v 2 . The system attempts to establish inferred definition locks, inf D L  (last(v 1 )), inf D L  (last(v 2 )), and inf D L  (last(v 3 )). Evaluation of the last(v 1 ) function results in an inferred definition lock, inf D L  (π A ), being placed on v 3 . Because evaluation of last(v 2 ) also gives π A , the same projection as the first argument, another inf D L  (π A ) is not placed on v 3 . When evaluated last(v 3 ) is a null because v 3  is a newly defined variable with no prior locks. An inferred definition lock does not need to be placed on the result variable of the assignment if the result variable is the same as one of the arguments, the result variable is being initially defined in the assignment, or the inferred definition lock would merely repeat a previous lock. After establishing locks on the affected variables, the system adds links to the variable lock table from the inferred definition locks back to the source use locks. One link will be from inf D L  (π A ) on v 3  back to U L  (T) on v 1 . Another link will be established from inf D L  (π A ) on v 3  back to U L  (T) on v 2 . 
     A write statement, w(c,v 3 ), such as S 5  in FIG. 1 causes the system to insert v 3  &#39;s identifier in the lock table if it is not already there. The system places a use lock, U L  (π A ), on v 3  in the lock table. 
     A projection π&#39;s subbegin statement, sb(π), such as S 1  in FIG. 1 causes the system to build a copy index for projection π by copying index information from the main index to another location. See FIG. 2. The system also creates a recovery block for projection π. The recovery block contains the program counter for the projection, the location of the projection&#39;s copy index, active variables at the start of the projection, other projections which are active at the projection π&#39;s start, and variables defined in the course of the projection. 
     A read statement for a projection π causes the system to append the variable to the defined variables section of projection π&#39;s recovery block. The defined variables section of the recovery block provides additional cross referencing between the recovery block and the lock table to speed the system. Write statements for a variable also append the variable to projection π&#39;s recovery block, if not already present there. Assignment statements do not have any affect on the recovery block because assignments do not affect the static store. 
     A projection π&#39;s subcommit statement, sc(π), such as S 9  in FIG. 1 causes the system to determine if projection π can commit without corrupting the database. Projections commit in the order that their subcommit commands arrive at the system scheduler. Projection π must delay commit if projection π depends on data from another projection or if another projection in the transaction is dependent on projection π. 
     In order to determine if projection π can commit, the system examines the last lock on each variable defined by the committing projection. If the last lock was placed by another projection then the projection cannot commit until the locking projection requests commit. To preserve the commit order, the scheduler records the order of commit requests. When the scheduler receives a commit request from the dependent projection, the system analyzes the dependencies for the dependent projection. If the system determines that the dependent projection can commit but for the original projection then the original projection is allowed to commit. 
     If the latest lock was not placed by another projection, the system examines all previous locks on the variable to determine if conflicting locks from another projection are on the variable. If locks are not held on any of the defined variables by other projections then the system will allow the current projection to commit. The system delays projection commit when the projection is dependent upon another projection as indicated by the existence of a use-definition lock conflict, definition-definition lock conflict, or inferred definition lock conflict on one of the projection&#39;s variables. In case of dependency, the system waits to commit the dependent projection until after the projection holding the lock commits. 
     On commit, locks held by the committing projection are released, the copy index is made the main index, and the recovery block can be removed. A commit notice for the projection is placed in the transaction&#39;s commit list. 
     When a projection is aborted because of a transaction error, the aborted transaction must first be examined to determine if any other projections depend on the aborted projection directly or indirectly. All currently dependent projections must be aborted with the originally aborted projection to insure database integrity. The system determines dependencies by examining the inferred definition locks held on the variables defined in the current projection. If a variable has an inferred definition lock placed on it that refers back to another projection or use-definition links which trace back to another projection then the projection is dependent on the other projection. 
     When only one projection is aborted, that projection can be restarted without loss of serializability because no other projections depend on that projection. On abort the aborting projection releases all of its use, definition and inferred definition locks. The system restarts the aborting projection by starting the projection at the recorded program counter location, reinitializing active variables, and active siblings. The projection acquires a new copy index. Variables from a committed projection are not altered. Access to the committed projections variables results in access to recovery block table copies of the variables on read operations and omission of the write statements. Execution continues until the restarted projection commits. 
     When the transaction ends, the system can commit all outstanding projections in the order received. Locks held by the transaction are released. The system deallocates the lock table and recovery block table. All remaining state information is deleted. 
     Operation of the recovery block table of FIG. 4 and the variable lock table of FIG. 5 shall now be explained with reference to the example transaction of FIG. 1. On receipt of the Tbegin statement, stable storage space is allocated for the variable lock table and the recovery block table. The subbegin command of S 1  causes insertion of projection π A  &#39;s program counter in the recovery block table. The main index of ADS A is copied to the copy index. All currently active variables and projections are inserted into the recovery block table. The defined variables section of the recovery block table will initially be empty. In S 2 , execution of a read command from database variable a to memory variable v 1  causes the system to record v 1  in the recovery block table and then in the variable lock table apply a definition lock to v 1  held by π A . Likewise in S 3 , v 2  is recorded and a definition lock is applied to v 2  which is held by π A . 
     An assignment command, v 3  :=f i  (v 1 ,v 2 ) is executed in S 4 , assigning the result of f(v 1 , v 2 ) to v 3 . The system inserts v 3  &#39;s identifier in the lock table and the recovery block table. The transaction, T, acquires use locks, U L  (T), in the lock table on each of the arguments of the assignment, v 1  and v 2 . The system attempts to establish inferred definition locks, inf D L  (last(v 1 )), inf D L  (last(v 2 )), and inf D L  (last(v 3 )). Evaluation of the last(v 1 ) function results in an inferred definition lock, inf D L  (π A ), being placed on v 3 . Because evaluation of last(v 2 ) also gives π A , the same projection as the first argument, another inf D L  (π A ) is not placed on v 3 . When evaluated last(v 3 ) is a null because v 3  is a newly defined variable not present in the recovery block table. An inferred definition lock does not need to be placed on the result variable of the assignment if the result variable is the same as one of the arguments, the result variable is being initially defined in the assignment, or the inferred definition lock would merely repeat a previous lock. After establishing locks on the affected variables, the system adds links to the variable lock table from the inferred definition locks back to the source use locks. These links are identified in FIG. 5 by the arrows pointing from the use locks U L  (T) on v 1  and v 2  to inf D L  (π A ) on v 3 . 
     S 5  executes a write command to write memory variable v 3  to database variable c. On receipt of this command, the system puts the location of v 3  in the recovery lock table because the v 3  location is not currently there. A use lock, U L  (π A ), is inserted for v 3  in the lock table. 
     Projection π B  is started by the subbegin command, sb(B), of S 6 . As in the S 1  subbegin command the projection&#39;s program counter is inserted in the recovery block table, and the main index of ADS B is copied to the copy index. Currently active variables, v 1 , v 2  and v 3 , and projection, π A , are inserted into the recovery block table. Initially, the defined variables section of the recovery block table is empty. S 7  executes a read command reading d into v 4 . The location of v 4  is written to the defined variables section of the recovery block table and to the variable lock table. A definition lock, D L  (π B ), is placed on v 4  because v 4  is defined by π B . S 8  assigns the result of a function of v 4  and v 3  to v 4 . This has no effect on the recovery block table because v 4  is already identified. In the lock table use locks, U L  (T), are placed on the arguments of the function, v 3  and v 4 . Inferred definition locks, inf D L  (π A ) and inf D L  (π B ), are placed on v 4  after evaluation of last(v 3 ) and last(v 4 ). A pointer is created between the use lock on v 3  and the inferred definition lock, inf D L  (π A ), on v 4 . A pointer is also created between the use lock on v 4  and the inferred definition lock, inf D L  (π B ), on v 4 . 
     The embodiment above uses a hierarchical lock table which allows the order of locking on each variable v to be determined. It is envisioned, however, that a non-hierarchical lock table would be effective for the purposes of this invention. The hierarchical lock table is preferred because it offers optimization in locating conflicts between projection. 
     A subcommit command for projection π A  is issued in S 9 . The system must evaluate the lock table to determine if projection π A  is dependent on any other projections. To do this, the system must search the lock table for all variables defined by projection π A . Starting with v 1 , the system analyzes the last lock on v 1 . Since this lock is a use lock, U L  (T), held by the transaction, no conflicts are created. The system then traces the chain of locks back to previous locks held on the active variables of the projection. No conflicts are created by the definition lock, D L  (π A ) on v 1  because it is held by π A , the projection that is currently attempting to commit. Analysis of the locks on v 2  occurs with the same result. Likewise, U L  (π A ) on v 3  creates no conflicts. U L  (T) on v 3  only locks against other transactions, and, therefore, it does not create any conflicts. 
     Because there are no conflicting locks on the variables v 1 , v 2  or v 3  of projection π A , it is allowed to commit. On commit, the ADS A copy index becomes the new ADS A main index, all locks held by projection π A  are released, and the projection π A  recovery block table entry is deallocated. Projection π A  &#39;s identifier is written to the transaction&#39;s commit list. 
     Statement S 10  issues a write command to write v 4  to e. Since e is a projection π B  database variable, a use lock, U L  (π B ), is placed on v 4 . In S 11 , a subcommit command, sc(B) is issued for projection π B . The system must determine if projection π B  is related to any other projections before projection π B  is allowed to commit. Since no other projections are active, projection π B  is allowed to commit. When projection π B  commits the ADS B copy index becomes the new ADS B main index, all locks held are released, the recovery block table entry is deallocated, and projection π B  &#39;s identifier is placed on the transaction&#39;s commit list. 
     When the system receives the transaction end command, Tend, it releases all locks, deallocates the lock table, and deallocates the recovery block table. 
     When a projection π 1 , aborts, the depends-on relationships between siblings are used to determine how to recover π 1  safely. If a sibling projection π 2  depends on the aborting projection π 1  then both projections abort. If π 1  depends on a sibling π 2  then π 1  aborts and π 2  suspends execution, and continues upon completion of π 1  &#39;s abort. If π 1  and π 2  depend on each other, both abort and restart. 
     When only one projection π 1  aborts, π 1  releases all of the use locks and definition locks held by it. π 1  also releases all of the inferred definition locks held by it. The aborted projection π 1  then restarts. 
     In the example shown in FIG. 1, π A  does not depend on π B , but π B  depends on π A . If π A  aborts, π B  must also abort. If π B  fails and π B  aborts, π A  need not abort. 
     If π B  fails, only π B  must be restarted since π A  does not depend on π B . First, π B  releases the use lock, U L  (π B ) on v 4 . π B  requests the release of inferred definition lock inf D L  (π B ), and inf D L  (π A ), which releases inferred definition locks held by π A  and π B . Transaction T releases use locks on variables v 4  and v 3   pointed to by the links between Transaction T&#39;s use locks, U L  (T) on v 3  and v 4 , and inferred definition locks on variable v 4 . π B  &#39;s definition lock, D L  (π B ) on variable v 4  is also released. 
     Referring now to FIG. 6 there is shown a flow chart displaying the steps necessary to restart an aborted projection. To restart execution of a projection π 1 , requires accessing π 1  &#39;s program counter, active variables at the initiation of π 1  and active siblings state at the initiation of π 1 . This information is used to perform replay of the projection π 1 . This will result in the reexecution of π 1  &#39;s code and reuse of sibling&#39;s active variables during execution. Execution starts by π 1  acquiring a new copy index. Variables from a committed projection π 2  are not altered. Access to committed sibling π 2  &#39;s variables results in access to copies and null instructions for π 2  &#39;s read and write operations on the physical database. Execution continues until projection π 1  &#39;s commit. 
     In the example of FIG. 1, if π A  fails, both π A  and π B  are aborted and restarted since π B  depends on π A . All entries for both projections are removed from the lock table. Projections π A  and π B  begin execution by acquiring π A  &#39;s and π B  &#39;s program counters from the recovery block. Execution is begun from the start of π A . New copy indexes are acquired and the projections reexecute as new projections. 
     If π B  fails after π A  has committed, π B  aborts and restarts. To restart π B  the system accesses π B  &#39;s program counter, active variables v 1 , v 2  and v 3  and active projection π A  &#39;s state. The program counter is reloaded with the start address for π B  and execution begins. Statement sb(B) initializes a new recovery block for π B  and acquires a new copy index for ADS B. Statement v 4  :=r(d) results in reading data item d into variable v 4 . A definition is acquired on variable v 4 . Statement v 4  :=f j  (v 4 , v 3 )&#39;s execution results in the acquisition of a use lock on v 4  and a use lock on variable v 3 . v 3  &#39;s value is recovered using active variable v 3  in the recovery block. Inferred definition locks are acquired on variable v 4  by π A  and π B . The subcommit statement, sc(A), is a null because projection π A  has already committed. 
     Statement w(e, v 4 )&#39;s execution results in π B  acquiring a use lock, U L  (π B ), on variable v 4 . When π B  commits, at sc(B) the use locks and definition locks for π B  and π A  are released. Projection π A  &#39;s and π B  &#39;s recovery blocks are maintained for possible replay with a sibling π&#39; which may depend on π A  or π B , or both. 
     If statements from π A  were reexecuted they would not alter any committed data items. On a read statements reexecution π A  would attempt to place definition lock on a variable, but since π A  has committed the statement executes as a null operation on the physical database. The read data would be recovered from π A  &#39;s saved variables. Likewise, if π A  were reexecuting a write statement, the projection requests a use lock on the variable to be written to ADS A. The use lock is rejected since π A  has committed. The write results in a null write execution to the physical database. Other statements such as assignments execute using variables previously defined during π A  &#39;s execution and by π B  during π B  &#39;s reexecution. 
     What has thus been described is a replay recovery protocol for real-time database management systems. The protocol allows greater access to data by maintaining locking by atomic data sets and projections rather than by transactions as in the prior art. 
     Obviously many modifications and variations of the present invention may become apparent in light of the above teachings. In light of the above, it is therefore understood that within the scope of the appended claims, the invention may be practiced otherwise than as specifically described.