Abstract:
A computer database method wherein the data is organized into atomic data sets and transactions are separated into projections which operate on only one atomic data set. Multiple transactions can thereby access the same atomic data set using a plurality of projections. A projection timestamp is generated by the system initial access to the atomic data set by the projection. Read and write timestamps are maintained separately by the atomic data set. Upon each read and write command, the issuing projection timestamp is compared against the appropriate atomic data set read or write timestamp. The operation succeeds if the compared timestamps do not indicate a conflict. Upon failure the projection is restarted with a new timestamp.

Description:
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, Ser. No. 08/238,045, now pending; Early Commit Optimistic Computer Database Protocol, Ser. No. 08/238,036, now pending; Replay Recovery Protocol for Real-Time Database Management Systems, Ser. No. 08/238,034, now pending; and Merge, Commit Recovery Protocol for Real-Time Database Management Systems, 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 a computer database method for providing an early database commit while increasing database concurrency and limiting cascading aborts to minimize the impact on recovery for a decomposed database and transaction system. 
     2. Description of the Prior Art 
     Real-time command, control and communications (C 3 ) systems control physical systems by extracting data from sensors, processing the extracted data, and performing control actions based on this processed data. Real-time C 3  systems are applied to applications where timeliness of data access, data processing and reactive responses are critical to the applications successful operations. 
     Real-time C 3  systems are being applied to a wide variety of physical systems, such as automotive control, aircraft control, spacecraft control, power management, automated factories, medical assistance and defense oriented systems. The main function of real-time C 3  systems is to manage and utilize information to control the real world environment. Therefore, these systems can be viewed as large information management systems that must respond in predictable ways and within specified time frames. 
     Real-time C 3  systems differ from conventional, general purpose systems in the sense that consistency and correctness of the real-time systems operation is dependent on the timeliness and predictability of responses to the controlled processes activities. In a real-time C 3  system, information is repeatedly collected from the physical system. Collected information is sampled, converted, formatted, timestamped and inserted into the control computer&#39;s database for each sampling period of the systems sensors. Stored data must be provided to the control software and system operators to be acted on to produce some desired control action. 
     Once the data is inserted into the database, it is used to compute a variety of related parameters. For example, raw sensor inputs from a radar system can be read and reduced to a bearing, range, and speed. These data items in turn can be used to compute detailed tracks of contacts, allowing for long-term tracking of an object. In addition, the raw information can be used to compute a profile on an object being tracked. This makes possible the classification and identification of an observed object. Transactions written to accomplish these computations require predictable and correct access, but not necessarily serializable access. 
     Real-time computing systems are being applied to a greater variety of control applications that require timely information. 
     Researchers are looking towards real-time computer systems as an emerging and important discipline in computer science and engineering. The real-time systems are characterized as possessing time dependent operations, reliable hardware and software, synergy with the controlled environment, predictable service. Predictability should be maintained not only in task scheduling, but also in scheduling all assets such as input/output, processing, communications, storage, and specialized controllers. 
     Databases within real-time systems must satisfy not only database consistency constraints but also timing constraints associated with transactions. 
     Responsive real-time databases must be predictable yet timely in their service. Real-time databases must incorporate features from real-time operating systems schedulers. A means to select the most appropriate database action to perform is necessary, and the scheduler must be adaptive to an ever changing real-time systems state. For correct database operations, real-time schedulers must be integrated with high performance concurrency control algorithms. 
     Recovery techniques based on rollback are not adequate in a real-time environment nor are present concurrency control techniques based on locking due to added blocking delays. Transactions must use non-serializable techniques, embedded transaction semantic knowledge, decomposition of transactions and the database to form more concurrent executions. 
     Transactions represent the unit of work recognized by users as being atomic. &#34;Atomic&#34; meaning that the operation or operations must complete execution or be aborted all together. Transactions serve the dual purpose as the unit for concurrency and recovery in database systems. Concurrency provides for indivisible access to data objects by concurrently executing users; and recovery provides for data restoration due to hardware, software, and transaction failures. 
     Due to these properties researchers look towards the use of transactions as a tool for structuring computations in distributed systems. 
     Research into transaction decomposition is relatively new; however, researches have studied breaking transactions into nested elementary transactions to increase concurrency. One approach to this is to decompose transactions into disjointed operations separated by breakpoints which breakpoints define allowable interleaving to allow increased concurrency. Another approach is to decompose transactions into data flow graphs of transaction computations steps which can be optimized to increase performance. 
     The data itself can also be decomposed into atomic data sets (ADS) to allow a more concurrent execution of decomposed transaction steps. Many researchers indicate that a finer granularity on data objects can increase data concurrency if managed properly. Availability and timeliness of data and processing has been pointed out as being a desirable feature in real-time database management systems and may be more important that consistency. Thus, the cited research indicates using transaction decomposition, database decomposition, and parallel and concurrent execution of database actions to provide for increased performance. 
     Concurrency control is used to ensure database consistency while allowing a set of transactions to execute concurrently. The problem solved by concurrency control is to allow non-interfering readers and writers free access, while controlling and coordinating the actions of conflicting readers and writers. There are three basic concurrency control approaches for transaction processing in database systems: locking, timestamp ordering and optimistic. The basic concurrency control techniques rely on syntactic information to make concurrency control decisions. The correctness of the algorithms is based on serializability theory. 
     These concurrency control techniques are inherently pessimistic. They avoid conflicts by enforcing serialization of conflicting database actions. Prior art literature points out that serializability as a correctness criteria is to stiff a requirement for real-time systems. Real-time concurrency control algorithms, must integrate real-time scheduling algorithms with concurrency control techniques. 
     Semantic information about transactions can be used to develop non-serializable scheduling of transaction steps that nonetheless are correct executions. A prior art method using this breaks transactions into a collection of disjoint classes. Transactions that belong to the same class are compatible allowing for arbitrary interleaving, whereas transactions that belong to different classes are incompatible and cannot interleave. Another prior art method defines a scheme wherein the transaction writing system decomposes transactions into steps upon which concurrency control can be performed. Transactions are broken at breakpoints, and type classes defined on the breakpoints. Transactions of compatible classes can interleave at this point, others cannot. A further refinement of this technique is achieved by using a larger volume of transaction class types which results in a finer granularity of breakpoints. This system increases concurrency by adopting a looser definition of correctness than serializability. 
     Other prior art research suggests the use of decomposition of both transactions and the database into finer granules to increase concurrency. In this theory the database and transactions are decomposed into atomic data sets (ADS) and elementary transactions respectively. Elementary transactions are executed concurrently on distributed assets of an ADS. This theory suggests that if elementary transactions are serialized with respect to an ADS then correct and consistent database executions result. 
     The aforementioned schemes do not address the issues in management of real-time data which are driven by the needs of the overall system, based on criticality of operations, nature of deadlines, and timing requirements. This paper develops and presents transaction concurrency control algorithms for real-time systems, based on decomposition of both the database and individual transactions, along with the application of criticalness, deadlines, and timing requirements to improve real-time database systems performance and predictability. 
     SUMMARY OF THE INVENTION 
     Accordingly, it is a general purpose and object of the present invention to provide a method for operation of a real-time database system. 
     It is a further object that such real-time database system provide a high degree of concurrency. 
     Another object is that such provide predictable results during transaction execution. 
     These objects are accomplished with the present invention by providing a computer database method wherein the data is organized into atomic data sets and transactions are separated into projections which operate on only one atomic data set. Multiple transactions can thereby access the same atomic data set using a plurality of projections. A projection timestamp is generated by the system initial access to the atomic data set by the projection. Read and write timestamps are maintained separately by the atomic data set. Upon each read and write command, the issuing projection timestamp is compared against the appropriate atomic data set read or write timestamp. The operation succeeds if the compared timestamps do not indicate a conflict. Upon failure the projection is restarted with a new timestamp. 
    
    
     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 a flow chart of the early-commit locking protocol of the current invention; 
     FIG. 2 shows a flow chart of the early-commit timestamp protocol of the current invention; 
     FIG. 3 shows a flow chart of the early-commit optimistic protocol of the current invention; 
     FIG. 4 shows a series of sample transactions illustrating operations of the current invention; and 
     FIG. 5 shows another series of sample transactions illustrating operations of the current invention. 
    
    
     DESCRIPTION OF THE PREFERRED EMBODIMENT 
     Database systems manage formatted collections of shared data. The database consists of collections of data fields, which are the finest granularity of data units available for users to manipulate. A data field is a basic data type such as name, age, address, etc. These basic data fields are organized into data items. Data items are the units for managing concurrency. Data items are not nested inside each other. Data items can be in the form of conventional records or objects. In this application theterms &#34;item&#34; and &#34;record&#34; are used interchangeably. 
     Relationships in the form of mathematical predicates are defined over itemsof the database. These predicates restrict the altering of database data items and structures. Database consistency means that all constraints are true. Constraints have the general form of predicates on database items. Constraints between data items of the database describe how database structures and items can be manipulated. 
     Constraints on database items are used to decompose the database into atomic data sets (ADSs). The database is a set of data items. Let i 1 ,i 2  be two distinct items from the set of database items. Let constraint, C(i 1 , i 2 ), hold if there is a constraint that refersto i 1  and i 2 . Let C&#39; denote the transitive and reflexive closure of C. The closure of constraints forms equivalence relations. The equivalence relations induced by C&#39; are called atomic data sets (ADSs). Consistency is maintained on each ADS in isolation from other ADSs. 
     Transactions define logical units of work on the database. Transactions have a lower bound (begin transaction, BT) and an upper bound (end transaction, ET) defining boundaries for transaction management. Between boundaries, transactions enclose operations on the database of the form: read a data item x, r(x) or write a data item x, w(x), and transaction code. 
     For example, consider the transaction of FIG. 1. Let v 1 , v 2 , v 3 , and v 4  be variables of transaction T. Let a,b,c, and d be data items from an ADS. Execution of statement S 6  : w(d, V 4 ) causes the variable V 4  to be written to the data item d. Statement S 1  : v 1  :=r(a) represents a read from data item a into variable v 1 . The reading of a data item into a variable defines the variables value. Statement S 5  is an assignment statement. Assignment statementsuse variables to define new or existing variables. Statements of this type are of the form v 0  :=f(vlist) where vlist represents a set of variables used in computing v 0   and f is a function performed over vlist. S 5  applies function f 1  using variables v 1 , v 2 , and v 3  to define variable v 4 . 
     The conventional transaction model is extended to include boundaries on atomic data set accesses. These boundaries are formed on the initiation ofaccess and termination of access to an atomic data set. The first request is preceded by a subbegin marker (sb) indicating the lower bound of accessby this transaction on a named ADS. Terminate can be either a subabort (sa)or subcommit (sc) operation indicating the upper bound of access by this transaction on a named ADS. 
     A transaction accessing an ADS A, acquires resources in A as needed and releases resources once the last access to ADS A is performed. Transactionwriters define when the first access to ADS A occurs and when the last access is performed. Boundaries for projections are formed using subbegin and subterminate statements. 
     After the last access to ADS A, a transaction cannot acquire more data items from ADS A. In this fashion the access and manipulation of ADS A, between the initial request for access until the final access forms a projection upon which concurrency control can be enforced. A projection π A  (i) contains all accesses to ADS A from transaction T i  andnone from any other transaction. 
     An example of projections from a transaction is shown in FIG. 2. In this example A and B are individual ADSs. Let a, b, and c be items from these ADS A, and d be an item from ADS B. Access to items in ADS A are bound in between sb (A) and sc (A) , or sa(A), and, likewise, accesses to ADS B arebound between sb(B) and sc(B), or sa(B). A statement that reads a data itemdefines the variable the data item is read into. A read statement is in theprojection controlling access to the data item read. 
     In the example of FIG. 2, statements S 1 , S 2 , S 3  define localvariables v 1 , v 2 , and v 3  by reading ADS A data items a, b, and c into these variables. Statements S 1 , S 2 , and S 3  are in projection π A  since variables v 1 , v 2 , and v 3  aredefined by reading data items from ADS A. Statement S 5  defines variable v 4  by reading data item d from ADS B into v 4 . StatementS 5  is in π B  by reading a data item from ADS B. 
     A statement that writes a data item defines the data item. A write statement is in the projection controlling access to the data item written. In the example of FIG. 1 statement S 6  defines data item d ofADS B when it performs the write operation w(d, v 4 ); therefore, statement S 6  is in projection π B . 
     A statement, S directly depends on a statement S&#39; if S follows S&#39; and S uses at least one variable defined by S&#39;. In the example of FIG. 1, assignment statement S 5  defines variable v 4  by performing a function f on variables in projection π A . Since statement S 5  uses variables from statements S 1 , S 2  and S 3 , S 5  directly depends on S 1 , S 2  and S 3 . 
     A statement S depends on a statement S&#39; if S directly depends on S&#39;, or there is a statement S* such that S directly depends on S* and S* depends on S&#39;. In the example of FIG. 1, write statement S 6  writes data item d using variable v 4 . Variable v 4  was defined in S 5 , therefore S 6  depends on S 5 . In addition since S 5  directly depends on S 1 , S 2  and S 3 , S 8  depends on S 1 , S 2  and S 3 . 
     A projection accesses data items outside of its boundaries by using statements in siblings. A projection π that uses statements that are inor depend on a sibling π&#39;, depend on π&#39;. In FIG. 1, statements S 5  and S 6  are in projection π B , and statements S 1 , S 2  and S 3  are in π A . Statement S 6  uses variable v 4  defined by statement S 5  which depends on statements S 1 , S 2  and S 3 . Since S 6  depends on S 5  and S 5  depends on statements in π A , then π B  depends on π A . 
     A projection π that depends on a sibling π&#39; cannot commit until π commits. In FIG. 2 projection π B  cannot commit until projection π A , is ready to commit. The delaying of commit will maintain the correctness of executions in the face of failures. 
     Projections act independently on ADS&#39;s. A projection acts on a single ADS reading data items into variables, using variables to perform computationsand to define variables and data items. If no interaction with sibling projections occur the projection can commit. If a projection uses a sibling&#39;s variables, it depends on the sibling projection. Dependent projections must wait for siblings to commit to do likewise. A projection that depends on no siblings need not delay. In FIG. 2, projection π A  can commit when ready since it does not depend on π B  orany other sibling. Projection π B  must delay commit until π A commits, since π B  depends on π A . Correct and consistent execution results if projections of a transaction coordinate in this fashion. 
     Projections from distinct transactions cannot use variables defined within other transactions. For correct and consistent execution, projections fromdistinct transactions must be committed serializably with each other on individual atomic data sets. 
     A projection π A  (i) from a transaction T i  and a projection π A  (j) from another transaction T j  that act on the same ADS Amust execute such that, the effects of the concurrently executing projections on the database either precede or follow each other. In the above example, projection π A  (i) of T i  either precedes execution of projection π A  (j) of T j  or π A  (i) follows the execution of projection π A  (j). The correct execution of conflicting projections is determined by formation of projection schedules for each atomic data set and checking if the schedules are serializable. 
     Conventional timestamp concurrency control determines serialization order at transaction start-up. The order is established by assigning a timestampto transactions as they begin, then checking these timestamps against others to determine if the order will be violated by an executing transaction&#39;s operation. 
     In conventional timestamp ordering, transactions operate by acquiring a timestamp at initiation, executing read and write accesses based on the timestamp ordering rule. The timestamp ordering (TSO) rule states that if OP i  [X] and OP j  [X] are conflicting operations from two distincttransactions T i  and T j  then the data manager processes OP i  [X] before OP j  [X] if and only if the timestamp of T i  is less than the timestamp of T j . All operations of transactions T i  and T j  follow this rule, thereby enforcing a serializable order of execution. 
     In the early commit timestamp ordering protocol of this invention, each transaction acquires multiple timestamps, one timestamp for each ADS accessed by the transaction. Each of these timestamps is then used to serialize access of conflicting transactions&#39; operations on distinct ADSs. 
     Like the conventional model, timestamps are used to order accesses. Accesses are handled the same as in conventional systems with requests forreads or writes to the data manager issued and either granted, if the timestamp of the requesting projection is greater than the timestamp of the data item, or rejected otherwise. 
     In FIG. 3 there is shown a flow chart of the early commit timestamp protocol of the current invention. When an initial access to an ADS is performed, a timestamp is allocated to the transaction&#39;s projection. On further accesses to the same ADS, this timestamp is used to order conflicting accesses for this projection only. Sibling projections use distinct timestamps to order accesses on distinct ADSs. 
     Timestamps must be unique and increase monotonically. Timestamps can be assigned in a variety of ways such as by using the system&#39;s real-time clock, by using a monotonically increasing counter or unique priority based indicator or the like. Our protocol enforces concurrency control on an ADS basis, limiting the efficiency of a single counter. To construct a timestamp, we use the ADS local counter along with the ADS identifier. 
     As transaction T&#39;s projections make initial access to some ADS A, they are given a timestamp for A by the rule: 
     
         TS(π.sub.A (T))=A-ID o A-local-counter. 
    
     The scheduler orders conflicting accesses from projections using the rule that the earliest projection&#39;s operations are scheduled before later projection&#39;s operations if the time stamp of the earlier projection&#39;s operation is less than that of the later projection&#39;s operation. 
     For example let π A  (i) and π A  (k) be two conflicting projections operating on ADS A, belonging to transaction T i  and T k  respectively. π A  (i)&#39;s conflicting accesses are scheduled before π A  (k) , if and only if TS (π A  (i))&lt;TS(π A  (k)). π A  (i) is the younger projection and π A  (k) the older. 
     The scheduler is required to compare timestamps on access to guarantee thatconflicts do not occur. The scheduler maintains two timestamps for each data item, a read timestamp RTS(X), which is the timestamp of the youngestprojection that has read data item X, and a write timestamp WTS(X), which is the timestamp of the youngest projection that has written data item X. Two tests are performed to guarantee correct ordering of reads and writes on ADSs. 
     On read of a data item X in ADS A: 
     
         TS(π.sub.A (i))≧WTS(X) 
    
     The timestamp of the requester projection π A  (i) must be greater than or equal to the write timestamp stored at the data item. This guarantees that the requester&#39;s read has come after any older projection&#39;swrite. 
     On a write of a data item X in ADS A: 
     
         TS(π.sub.A (i))≧RTS(X) and TS(π.sub.A (i))≧WTS(X) 
    
     On a write request by π A  (i), the requester&#39;s timestamp is comparedto both the data item&#39;s read timestamp (RTS(X)) and write timestamp (WTS(X)). If the requester&#39;s timestamp is greater than or equal to the ADS&#39;s read and write timestamps, then the request is granted and the ADS timestamps adjusted. If not, the request is refused and the requester, projection π A  (i), is aborted and restarted. 
     Until commit of the projection, all changes to the database are recorded instable store pointed to by the projection&#39;s copy index and are not available for other projections to use. On projection commit the changes are entered into the database. If aborted, all data items accessed by the projection π A  (i) have their read timestamp (RTS) and write timestamp (WTS) as well as data changes purged from the copy index. The projection is then restarted with a new timestamp. 
     In FIG. 4, the timestamp protocol would order access to ADS A by π A (1)&lt;π A  (2) and ADS B by π B  (2)&lt;π B  (1). This ordering occurs since the timestamp acquired for π A  (1) is less than the timestamp of projection π A  (2), and the timestamp acquired for projections acting on ADS B show the timestamp of π B  (2) is less than the timestamp for projection π B  (1). 
     If conflict results in failure, the failed projection is aborted and restarted. Other projections of the transaction are not affected. For example, in FIG. 5, two projections operate on the same ADS from distinct transactions and conflict. The read timestamp and write timestamp for ADS A&#39;s data item a are initially set to X. Let r(a) and w(a) represent the read and write on ADS A&#39;s data item a respectively. Let TS(π A  (1))=X, represent the timestamp for projection π A  (1) of transaction T, on ADS A at time t. 
     At time t 1 , projection π A  (1) receives a timestamp TS=X from ADS A and uses this to read data item a from ADS A. The test of the ADS read timestamp is successful, and the read timestamp is updated. At time t 2 , transaction T 2  acquires a timestamp from ADS A equal to X+1.T 2  uses this timestamp to read a data item and update the read timestamp of ADS A. At time t 3 , transaction T 2  issues a write request. Projection π A  (2) uses its timestamp=X+1 to test if the write is acceptable. The test for a write is correct, since TS(π A  (2))≦RTS and TS(π A  (2))≦WTS of ADS A which allows the write to occur at time t 3 . At time t 4 , π A  (1) tries to write to ADS A, but fails the write timestamp test since its timestamp tests finds that TS(π A  (1))&lt;RTS and TS(π A  (2))&lt;WTS of ADS A. Accordingly Transaction T 1  must abort and restart its projection on ADS A. 
     Transactions under the early commit timestamp protocol commit projections before transaction completion thereby allowing projection results to be available for other transactions and increasing concurrency. Added concurrency results from shorter periods of conflict time than entire transaction run times as in conventional timestamp ordering. Primitives toaccess information are the same as conventional accesses but are interpreted by the scheduler differently. Each access is directed to a named ADS and only affects that ADS. 
     The early commit timestamp protocol requires two additional elements, an ADS counter generator and storage for data item read and write timestamps.Each ADS in the database requires a distinct counter associated with it. This counter is incremented on each projection&#39;s subbegin operation. The value computed is then associated with the projection&#39;s recovery block table and the projection copy index. 
     The copy index requires added storage for pointers to manage the read and write timestamps for the data items. Added storage would require additional fields to hold the read and write timestamps. This added storage would be reflected in each projection&#39;s copy index. An alternativeto save on storage is to associate a pointer to a read set and write set storage area. This alternative would require less overall storage at the cost of an added indirection to access the required information. 
     A projection uses the computed timestamp, read set, and write set to control concurrent access to data items and ensure projections serializably access ADSs by the timestamp ordering rules mentioned previously. Each ADS maintains a timestamp separate from all other ADSs. In this way, projections operating on a particular ADS are scheduled serializably in isolation from projections acting on other ADSs. 
     Terminology in this disclosure indicates the use of time as the prioritizing indicia; however, other prioritizing methods can be used as long as the timestamp assigned to a projection assures serial determination. For example, data from a particular source can have greatervalue than other data and take precedence over the other data when updatingthe system. Accordingly, the preferred data can be given a timestamp with ahigher priority. 
     The early commit timestamp protocol of the current invention differs from conventional protocols in fundamental ways. The database is composed of a collection of atomic data sets instead of a single monolithic database. Each ADS maintains consistency in isolation from other ADSs. Transaction operations are partitioned over ADSs. Each transaction&#39;s collection of operations on an ADS constitutes a projection of these operations over theADS. Projections from distinct transactions operate on individual ADSs serializably. 
     Obviously many modifications and variations of the present invention may become apparent in light of the above teachings. In light of the above, itis therefore understood that within the scope of the appended claims, the invention may be practiced otherwise than as specifically described.