Patent Publication Number: US-7899799-B2

Title: Transaction processing system of database using multi-operation processing providing concurrency control of transactions

Description:
FIELD OF INVENTION 
     The present invention is related to transaction processing system of database and especially related to concurrency control of transactions where multiple transactions are executed concurrently for the same access areas. 
     RELATED APPLICATIONS 
     Japanese Patent Application No. 2006-356406 
     Japanese Patent Application No. 2007-075670 
     Japanese Patent Application No. 2008-120540 
     U.S. patent application Ser. No. 12/149,059 
     BACKGROUND OF THE INVENTION 
     A database management system concurrently executes a large number of transactions submitted from multiple users through a network. However, if multiple transactions are executed on the same data items concurrently, data inconsistency may occur. Therefore, in order to avoid any data consistency to occur, the database management system uses concurrency control to execute multiple transactions. 
     &lt;Serializable Schedule&gt; 
     In order to execute multiple transactions without causing any data inconsistency, the easiest method is to execute each transaction one by one. This method is called serial scheduling, in which execution of a subsequent transaction cannot be started until the execution of a current transaction is completed. 
     The problem of serial scheduling is that it limits concurrency or interleaving of operations. In a serial schedule, if a transaction waits for an I/O operation to complete, the CPU processor cannot be switched to another transaction, thus wasting valuable CPU processing time and making serial schedule generally unacceptable. 
     Thus, in order to execute multiple transactions concurrently without causing any data inconsistency, serializable scheduling is used. 
     In order to achieve a serializable schedule, a locking method is used for data items to be processed by multiple transactions. There are several types of locks such as shared lock and exclusive lock. A shared lock is a read lock which is used by a transaction to only read a data item; thus if one transaction is using a shared lock to read a data item, other transactions can read the data item but cannot update or delete the data item until the shared lock is released from the data item. An exclusive lock is a write lock which is used by a transaction to read and write a data item; thus, if one transaction is using an exclusive lock to update a data item, other transactions cannot read, delete, or update the data item until the exclusive lock is released from the data item. 
     However, only using locks may cause a data inconsistency between multiple transactions depending on some locking orders. Therefore, if multiple transactions need to lock the same data items, a method of creating a dependency graph representing the locking order for the transactions is used. If there is a cycle in the dependency graph, this means that there is a data inconsistency between some of these transactions; therefore, all of the transactions in the dependency graph are aborted, and the aborted transactions are then restarted from the beginning. If there is no cycle in the dependency graph, all of the transactions are executed correctly without causing any data inconsistency. 
     However, each time a cycle appears in the dependency graph, transactions are aborted repeatedly and thus this method is inefficient. Moreover, the serializable schedule may not be available even if the transactions are restarted many times. Therefore, there are protocols that guarantees serializable schedule such as two-phase locking protocol, optimistic locking protocol, timestamp protocol, multi-version protocol, etc. 
     (1) Two-Phase Locking Protocol 
     The two-phase locking protocol divides lock operations into two phases: a growing phase, during which acquiring of new locks on data items is allowed but none can be released; and a shrinking phase, during which existing locks can be released but no new locks can be acquired; thus, acquiring a lock again after releasing a lock is not allowed. 
     Also during the growing phase, upgrading of locks is allowed in addition to acquiring locks, and during the shrinking phase, downgrading of the lock is allowed in addition to releasing locks. 
     In order to ensure a serializable schedule, all transactions in a schedule need to be executed with the two-phase locking protocol. 
     However, in the two-phase locking protocol, if multiple transactions hold the locks required by each other and any of their operations cannot be performed, a deadlock occurs. In order to remove the deadlock, one of transactions holding its locks needs to be aborted, rolled back, and resubmitted to the transaction processing system. 
     In addition, if other transactions read the value of the data item written by the aborted transaction, these transactions are also aborted, rolled back, and resubmitted to the transaction processing system. The effect of aborting a transaction causes another transactions to abort in a chain reaction is called cascading rollback. 
     In order to avoid cascading rollback, a strict two-phase locking protocol can be used. This method has an additional condition that a transaction does not release its first lock in the shrinking phase until the transaction is committed or aborted. 
     While this method prevents cascading rollback, the time of holding locks by each transaction becomes longer. 
     &lt;Problem of Two-Phase Locking&gt; 
     In the two-phase locking protocol, if the number of transactions to be executed concurrently increases, a lock contention may occur between multiple transactions, and thereby a deadlock can easily occur. As a result, many transactions are aborted and rolled back to remove the deadlock, thus causing transaction processing speed to decrease. 
     In the two-phase locking protocol, if multiple transactions are performed on the same data item, the same data item is locked by each transaction repeatedly so that while one transaction is holding a lock on the data item, other transactions must wait until that lock is released. 
     The two-phase locking protocol uses an operating system process to execute each transaction. However, if the operation system switches processes while one transaction is holding a lock on a data item, the other transaction requiring to process the data item cannot acquire a lock to the data item even if it has received processing time from a CPU (microprocessor); then, if the operating system switches the processes again, the other transaction is not able to perform any operation. Therefore, if the number of transactions to be executed concurrently increases, this situation occurs repeatedly, slowing down the transaction processing speed significantly. 
     (2) Optimistic Locking Protocol 
     The optimistic locking protocol executes each transaction by assuming that there is no contention in executing the transaction, and then checks for any contention when the transaction ends. If there is contention, it aborts and rollbacks the transaction. If there is no contention, it locks the data items to be written, performs the write operations, and commits the transaction. Since this method does not hold any locks while processing a transaction, the time for acquiring locks is only a short period just before committing the transaction. 
     &lt;Problem of Optimistic Locking Protocol&gt; 
     Similar to the problem of the two-phase locking protocol, there are problems in the optimistic locking protocol such as, if the number of transactions to be executed concurrently increases, the number of transactions that compete to update data items increases so that the number of transactions that abort and rollback also increases. 
     (3) Timestamp Protocol 
     In order to execute multiple transactions concurrently, the timestamp protocol assigns a timestamp (arrival time) to each transaction and executes the multiple transactions in the order from the transaction of smaller timestamp (early arrival time) to transaction of larger timestamp (late arrival time). 
     Each data item to be processed by a transaction is also given a read timestamp and a write timestamp; then the transactions are executed based on the following rules. 
     When a transaction performs a read operation on a data item, the timestamp of the transaction and the write timestamp of the data item are compared. If the timestamp of the transaction is smaller, the transaction is aborted because the value of the data item to be read by the transaction is already lost. Otherwise, the transaction is executed and the read timestamp of the data item is set to the timestamp of the transaction. 
     When a transaction performs a write operation on a data item, the timestamp of the transaction and the read timestamp of the data item are compared. If the timestamp of the transaction is smaller, the transaction is aborted because another transaction, which supposed to read the data item after being written by the first transaction, read that data item first. 
     Moreover, if the timestamp of the transaction is larger than the read timestamp of the data item and smaller than the write timestamp of the data item, the transaction is aborted because the transaction has missed the time to perform its write operation. Otherwise, the transaction is executed and the write timestamp of the data item is set to the timestamp of the transaction if the timestamp of the transaction is larger than the write timestamp of the data item. 
     The aborted transactions mentioned above are rolled back, resubmitted to the transaction processing system, and then given new timestamps. 
     Timestamp protocol can use the technique called Thomas&#39;s write rule to reduce the number of transactions to be aborted. 
     With this technique, when a transaction performs a write operation on a data item, if the timestamp of the transaction is greater than the read timestamp of the data item and smaller than the write timestamp of the data item, the transaction has missed the time to perform its write operation; however, if the database and other transactions are not affected, the transaction ignores the write operation and continues its execution. 
     &lt;Problem of Timestamp Protocol&gt; 
     Since the timestamp protocol does not use locks, a deadlock does not occur. However, if the number of transactions to be executed concurrently increases, the multiple transactions may not be executed for a data item in the right order, thus causing many transactions to be aborted, rolled back, and resubmitted to the transaction processing system. If such operation occurs repeatedly, a problem such as transactions never completing occurs. 
     (4) Multi-Version Technique 
     The multi-version technique is a method that keeps track of multiple values of a single data item by storing the previous value of the data item when a transaction writes the data item. Then, when multiple transactions are each executed on the same data item, the appropriate version of the data item is selected for each transaction to reduce the number of transactions to be aborted. There is a multi-version technique applying the two-phase locking protocol as well as the timestamp protocol. 
     &lt;Problem of Multi-Version Technique&gt; 
     The problem of the multi-version technique is that additional storage space is required for storing multiple values for each data item. 
     [Patent Document 1] 
     
         
         Japanese Unexamined Patent Application Publication No. Hei 07-084864
 
[Patent Document 2]
 
         Japanese Unexamined Patent Application Publication No. Hei 07-200372
 
[Patent Document 3]
 
         Japanese Unexamined Patent Application Publication No. Hei 10-320258
 
[Patent Document 4]
 
         Japanese Unexamined Patent Application Publication No. 2002-32249
 
[Patent Document 5]
 
         U.S. Pat. No. 5,280,619 Jan. 18, 1994 
       
    
     System for accessing shared data using a serialization graph constructed from a history file showing completed locking dependencies between transactions 
     [Non-Patent Document 1] 
     
         
         Hiroyuki Kitagawa, Database System, pp. 147-173, Textbook of Information System Series Volume 14, SHOKODO CO., LTD., First Print Published in Jul. 10, 1996
 
[Non-Patent Document 2]
 
         Ramez Elmasri, Shamkant B. Navathe, Fundamentals of Database Systems Second Edition, pp. 527-575, Addison-Wesley Publishing Company, 1994
 
[Non-Patent Document 3]
 
         Kazuimi Kanehiro, Knowledge and Practice of Database Carefully Taught By an Expert, pp. 88-105, SHOEISHA. CO., LTD., 2007 
       
    
    
    
     
       BRIEF EXPLANATION OF THE DRAWINGS 
         FIG. 1  is a diagram showing the architecture of a transaction processing system. 
         FIG. 2-1  is a diagram showing a flowchart of the transaction processing system. 
         FIG. 2-2  is a diagram showing a flowchart of the transaction processing system. 
         FIG. 3-1  is a diagram showing an exemplary database relation. 
         FIG. 3-2  is a diagram showing an exemplary database relation. 
         FIG. 4  is a diagram showing an exemplary precedence graph indicating data update order by multiple transactions. 
         FIG. 5-1  is a diagram showing an example of multi-operation processing using two-phase locking. 
         FIG. 5-2  is a diagram showing an example of multi-operation processing using two-phase locking. 
         FIG. 6  is a diagram showing an exemplary deadlock caused by multiple synthetic transactions. 
         FIG. 7  is a diagram showing an example of multi-operation processing using timestamps. 
         FIG. 8  is a diagram showing query trees and precedence graphs. 
         FIG. 9  shows a table (a) and a graph (b) of experiment results evaluating multi-operation processing providing concurrency control of transactions. 
         FIG. 10  shows a table (a) and a graph (b) of experiment results evaluating multi-operation processing providing concurrency control of transactions. 
     
    
    
     DESCRIPTION OF THE INVENTION 
     Problem to be Solved by the Invention 
     The conventional transaction processing system is not an efficient method as it has the above mentioned problems. Since the conventional method executes each transaction separately, if the number of transactions to be executed concurrently increases, the same data item is read and written by each transaction repeatedly, thus causing many transactions to compete so that the number of transactions that abort and rollback also increases. Therefore, the transaction processing speed is decreased. 
     With the present invention, instead of executing multiple transactions separately, each data item to be processed by the multiple transactions is retrieved only once, the update operations of the multiple transactions are executed consecutively on the retrieved data item in main memory, and only the last updated result is written in a database once. 
     Means of Solving the Problem 
     In order to achieve the above mentioned purpose, we propose a transaction processing system of database using multi-operation processing providing concurrency control of transactions. The transaction processing system includes transaction execution order determination means for determining a transaction execution order for a plurality of submitted transactions; precedence graph creating means for creating a precedence graph indicating to update data in the determined transaction execution order when a plurality of transactions performs its operation on the same data item by creating an edge for the data item and drawing it from the vertex of the first transaction to perform its operation to vertex of the next transaction to perform its operation; task retrieval means for retrieving partial operations contained in the plurality of transactions as tasks; grouping means for grouping the retrieved tasks into groups for each access area of the database in the transaction execution order; synthetic transaction creating means for creating a synthetic transaction using the groups created by grouping; and multi-operation processing means for executing each group contained in the synthetic transaction using multi-operation processing, wherein the multi-operation processing means finds blocks in the access area to be accessed by the grouped tasks, determines an access order for the blocks in the lined up order of the tasks in the group, reads a block in the determined access order, extracts tasks accessing the read block from the group, executes the task operations consecutively on a data item in the block in the lined up order of the tasks in the group, determines whether an ended transaction can be committed based on whether an incoming edge to the vertex of the ended transaction in the precedence graph exists at this time when execution of a grouped task is finished and the transaction containing the finished task is ended, commits the transaction if the vertex of the ended transaction does not have any incoming edges, and removes the vertex of the transaction and all of the outgoing edges from the vertex; a process of executing the task operations consecutively on a data item in the block in the lined up order of the tasks in the group means executing the task operations, which are partial operations of the transactions, consecutively on the data item according to the transaction execution order indicated in the precedence graph if the data item in the block exists in the precedence graph, that is, when the plurality of tasks performs its update operation on the data item, the update operation of the first task is executed on the data item, the update operation of the next task is executed on the updated data item, such update operation is repeated in this manner, and only the last updated result is written in the database once after the update operation of the last task is executed. 
     Also, two-phase locking protocol or timestamp protocol is used to execute multiple synthetic transactions concurrently. 
     A program corresponding to respective functions of the above transaction processing system of database, which is executed by a computer system, and a storage medium stored with this program are also aspects of the present invention. 
     Result of the Invention 
     By using the present invention: multi-operation processing providing concurrency control of transactions, unlike the conventional transaction processing, retrieving the same data item many times repeatedly, executing an update operation on the retrieved data item separately, and writing the updated result in a database many times repeatedly are no longer required for each transaction in executing multiple submitted transactions. 
     With the system of the present invention, the data item to be processed by multiple transactions is retrieved only once, the update operations of the multiple transactions are executed consecutively on the retrieved data item in the main memory, and only the last updated result is written in the database once; thereby improving the transaction processing speed. 
     Furthermore, because multi-operation processing is used, the block storing the data items to be processed by multiple transactions is required to be read only once from a disk. 
     Since the system of the present invention creates a single synthetic transaction for multiple submitted transactions and each group contained in the synthetic transaction is executed for a different relation, even if the multiple groups contained in the synthetic transaction are executed concurrently, the same data items are not accessed simultaneously by the multiple groups. Also, tasks collected into a group are executed consecutively for a data item in the block read into the main memory according to the transaction execution order indicated in the precedence graph. As a result, no locks are required between the multiple transactions synthesized in the synthetic transaction, and making transactions wait and aborting transactions are no longer required. 
     The system of the present invention creates a single synthetic transaction for multiple submitted transactions and executes the synthetic transaction. After the synthetic transaction is executed, if new multiple transactions are submitted, the system creates another synthetic transaction for the newly arrived transactions and executes that synthetic transaction. Therefore, as long as synthetic transactions are executed serially, no locks are required, deadlocks do not occur, and the multiple groups contained in each synthetic transaction are executed concurrently. 
     The processing speed of executing multiple transactions can be improved significantly by executing synthetic transactions serially; however, when concurrent execution of multiple synthetic transactions is required, multi-operation processing using two-phase locking or multi-operation processing using timestamps can be used to utilize hardware resources such as a CPU and a disk effectively. 
     In multi-operation processing using two-phase locking, each transaction does not acquire locks as with the conventional two-phase locking protocol; instead, a synthetic transaction created from a large number of transactions acquires locks. This allows reduction in the number of resource usages for operating system processes and locks. 
     THE BEST MODE FOR CARRYING OUT THE INVENTION 
     In order to execute a large number of transactions efficiently in parallel, the present invention proposes a transaction processing system of database using multi-operation processing providing concurrency control of transactions. 
     In addition, in order to execute multiple synthetic transactions concurrently, the present invention also proposes multi-operation processing using two-phase locking, which adds a two-phase locking technique to the multi-operation processing providing concurrency control of transactions; and multi-operation processing using timestamps, which adds a timestamp technique to the multi-operation processing providing concurrency control of transactions. 
     The inventor of the present invention previously proposed “Query Processing System of Database Using Multi-Operation Processing”, which only dealt with query processing (Refer to U.S. Pat. No. 4,109,305). 
     The main difference between the present invention, multi-operation processing providing concurrency control of transactions, and the previous invention, multi-operation processing dealing only with query processing, is that transactions to perform update operations are also executed with the present invention in addition to transactions to perform only retrieve operations (queries). 
     &lt;Structure of Database Management System&gt; 
       FIG. 1  shows the architecture of the present invention: a transaction processing system of database using multi-operation processing providing concurrency control of transactions. This architecture consists of software modules such as a transaction processing system  100 , a queue  103 , a multi-operation processor  102  and related devices on a computer system  105  including a microprocessor (CPU), main memory, and a secondary storage (disk). 
     First, if multiple transactions T 1 , T 2 , . . . , T 8  written in a database language such as SQL are submitted to the transaction processing system  100  from multiple users, the transaction processing system obtains partial operations of the submitted transactions, determines a transaction execution order, creates a precedence graph indicating to update data in the transaction execution order, retrieves the partial operations contained in the transactions as tasks, divides the retrieved tasks into groups for each database relation (access area) to create the groups G 1  and G 2  (because transactions T 1 , T 2 , . . . , T 8  must be executed for two different relations in total), creates a synthetic transaction T G1,G2  using the created groups G 1  and G 2 , and inserts the synthetic transaction T G1,G2  into the queue  103 . 
     After inserting the synthetic transaction T G1,G2  into the queue  103 , the multi-operation processor  102  retrieves the synthetic transaction T G1,G2  from the queue  103 . If there are five operating system processes available for the transaction processing system, process  1  executes group G 1  contained in the synthetic transaction T G1,G2  using multi-operation processing, and process  2  executes group G 2  contained in the synthetic transaction T G1,G2  using multi-operation processing. 
     Next, after retrieving the synthetic transaction T G1,G2  from the queue  103 , if new transactions T 9 , T 10 , and T 11  are submitted to the transaction processing system  100 , similarly for the submitted transactions T 9 , T 10 , and T 11 , the transaction processing system  100  obtains partial operations of the transactions T 9 , T 10 , and T 11 , determines a transaction execution order, creates a precedence graph indicating to update data in the transaction execution order, retrieves the partial operations contained in the transactions as tasks, divides the retrieved tasks into groups for each database relation to create groups G 3 , G 4 , and G 5  (because the transactions T 9 , T 10 , and T 11  must be executed for three different relations in total), creates a synthetic transaction T G3,G4,G5  by using the created groups G 3 , G 4 , and G 5 , and inserts the synthetic transaction T G3,G4,G5  into the queue  103 . 
     If the multi-operation processor ( 102 ) is currently executing the synthetic transaction T G1,G2  using process  1  and process  2 , the remaining processes, process  3 , process  4 , and process  5  are used to execute the synthetic transaction T G3,G4,G5 . 
     &lt;Flowchart of Transaction Processing System Using Multi-Operation Processing&gt; 
     The flowcharts of  FIG. 2-1  and  FIG. 2-2  specify a series of executing transactions on the transaction processing system of database using multi-operation processing providing concurrency control of transactions. 
     First, in  FIG. 2-1 , transactions T 1 , T 2 , T 3 , . . . , T S  written in a relational database language such as structured query language (SQL) are submitted to the transaction processing system  100  of the database server from multiple users (S 200 ). 
     The transaction processing system  100  creates partial operations of the transactions by transforming the submitted transactions into executable operations (S 201 ). Once the partial operations of the transactions are created, a transaction execution order is determined (S 202 ). 
     After determining the transaction execution order, a precedence graph having transactions T 1 , T 2 , T 3 , . . . , T S  as vertices is created (S 203 ). 
     In creating the precedence graph, if some of the transactions T 1 , T 2 , T 3 , . . . T S  perform their operations on the same data item, a directed edge is created for the data item and is drawn from the vertex of the first transaction to perform its operation to the vertex of subsequent transaction to perform its operation to clarify the transaction execution order for the data item. 
     After creating the precedence graph, the partial operations contained in the transactions are retrieved as tasks and the retrieved tasks are divided into groups for each database relation (access area) to create groups G 1 , G 2 , . . . , Gn (S 204 ). 
     Then, by using the created groups G 1 , G 2 , . . . , Gn, a synthetic transaction T G1, G2, . . . , Gn  is created (S 205 ). 
     Each group Gi (i=1, 2, . . . , n) contained in the synthetic transaction T G1, G2, . . . , Gn  is executed using the multi-operation processor  102  (S 206 ). 
     The multi-operation processor  102  finds blocks to be accessed by each task in the group and collects the blocks into a block set (S 207 ). 
     Once the blocks are collected into block sets, a block access order is determined in the lined up order of the tasks in the group (S 208 ). 
     The multi-operation processor  102  reads a block in the determined block access order, extracts tasks accessing the read block from the group, and 
     executes the task operations consecutively on a data item in the block in the lined up order of the tasks in the group (S 209 ). 
     Once the execution of a task for the block is finished ( FIG. 2-2 : S 210 ), check whether the transaction containing the finished task is ended (S 211 ). 
     Whether the transaction is ended is checked based on whether the execution of all of the tasks contained in the transaction is finished. 
     If the transaction is not ended, check whether all of the blocks specified in the block access order have been accessed (S 217 ). 
     If the transaction is ended, determine whether the transaction can be committed at this time based on the precedence graph (S 212 ). 
     Whether the transaction can be committed at this time is determined based on whether the vertex of the ended transaction contains an incoming edge in the precedence graph. 
     If an incoming edge exists in the vertex of the ended transaction and thus the transaction cannot be committed at this time, the transaction is left as a commit-waiting transaction (S 216 ). 
     If there are no incoming edges so that the transaction can be committed, the transaction is committed (S 213 ) and the vertex of the transaction and all of the outgoing edges from the vertex are removed from the precedence graph (S 214 ). 
     Also, if removing the edges causes the vertex of some other commit-waiting transaction to lose all of its incoming edges (S 215 ), the other transaction is also committed, and the vertex of the transaction and all of the outgoing edges from the vertex are also removed from the precedence graph. In this manner, transactions are committed repeatedly (S 213 ). 
     Once the operations for the accessed block are finished, check whether all of the blocks specified in the block access order have been accessed (S 217 ). 
     If un-accessed blocks still remain, the multi-operation processor  102  reads the next block to be accessed from the disk in the block access order, extracts tasks accessing the read block from the group, and, executes the task operations, which are partial operations of the transactions, consecutively on a data item in the read block in the lined up order of the tasks in the group ( 209 ). 
     Once all of the blocks specified in the block access order are accessed, the group execution is completed (S 218 ). 
     Once the group execution is completed, check whether all of the groups contained in the synthetic transaction have been executed (S 219 ). 
     If some groups still remain, the next group is retrieved from the synthetic transaction and executed using multi-operation processing. 
     Group execution is repeated in this manner (S 206 ). 
     Once all of the groups contained in the synthetic transaction are executed, the execution of the synthetic transaction is completed. As a result, all of the submitted transactions T 1 , T 2 , T 3 , . . . , T S  are executed and committed (S 220 ). 
     A summary of multi-operation processing providing concurrency control of transactions has been described with  FIG. 1 ,  FIG. 2-1 , and  FIG. 2-2 . 
     In the following section, the transaction processing system of database using multi-operation processing providing concurrency control of transactions is described in more detail. 
     In Section 1, steps and examples of transaction processing using multi-operation processing providing concurrency control of transactions are given. In Section 2, two techniques: multi-operation processing using two-phase locking; and multi-operation processing using timestamps are proposed for concurrent execution of multiple synthetic transactions. Steps and examples of executing multiple synthetic transactions concurrently are then given using these techniques. 
     In Section 3, a specific example of processing transactions having complex and advanced queries including join operations by using multi-operation processing providing concurrency control of transactions is given. 
     In Section 4, in order to compare the transaction processing speed of the two-phase locking protocol of conventional transaction processing and the transaction processing speed of multi-operation processing providing concurrency control of transactions according to the present invention, our originally designed database management system software MOP-DB is used to show experiment results of using each method. 
     1. Multi-Operation Processing Providing Concurrency Control of Transactions 
     1.1 Steps of Multi-Operation Processing Providing Concurrency Control of Transactions 
     [(1) Creating Partial Operations of Transactions (S 201 )] 
     When multiple transactions T 1 , T 2 , T 3 , . . . , T s  are submitted to the database management system (S 200 ), partial operations of the transaction specifying a write operation on record r as write_item(r) and a read operation on record r as read_item(r) are created for each transaction (S 201 ). 
     [(2) Determining a Transaction Execution Order] 
     Once the partial operations of the transactions are obtained, a transaction execution order is determined for the submitted multiple transactions T 1 , T 2 , T 3 , . . . , T s (S 202 ). 
     In order to determine the transaction execution order, the processing cost of each transaction is obtained based on the partial operations of the transaction, and the transactions are then sorted in the order from the transaction of smaller processing cost to the transaction of larger processing cost to determine the transaction execution order. 
     In some case, if the arrival time of a transaction is more important than the processing cost of a transaction, the transaction arrival time can be used to sort the transactions to determine the transaction execution order. 
     [(3) Creating a Precedence Graph (S 203 )] 
     After determining the transaction execution order, a precedence graph having transactions T 1 , T 2 , T 3 , . . . , T s  as vertices is created (S 203 ). In creating the precedence graph, if some of transactions T 1 , T 2 , T 3 , . . . , T s  perform their operations on the same data item, a directed edge is created for the data item and is drawn from the vertex of the first transaction to perform its operation to vertex of the subsequent transaction to perform its operation. 
     When the transactions are sorted in the order of transaction processing cost, an edge is drawn from the vertex of the transaction having smaller processing cost to the vertex of the transaction having larger processing cost. 
     On the other hand, when the transactions are sorted in the order of transaction arrival time, an edge is drawn from the vertex of the transaction arriving first to the vertex of the transaction arriving next. 
     [(4) Grouping Tasks (S 204 )] 
     Each partial operation such as an update operation and a retrieve operation contained in transactions T 1 , T 2 , T 3 , . . . , T s  is retrieved as task t i   j  (i denotes transaction number, j denotes operation number in the transaction) and divided into groups for each database relation, which is the access area of the database, to create groups G 1 , G 2 , . . . , Gn ( 204 ) in the transaction execution order. 
     [(5) Creating a Synthetic Transaction (S 205 )] 
     After dividing the tasks into groups for each database relation, a synthetic transaction T G1, G2, . . . , Gn  is created using the created groups G 1 , G 2 , . . . , Gn (S 205 ). 
     In order to execute the synthetic transaction T G1, G2, . . . , Gn , each group contained in the synthetic transaction T G1, G2, . . . , Gn  is executed using multi-operation processing. 
     [(6) Executing Each Group Using Multi-Operation Processing] 
     First, group G 1  is retrieved from the synthetic transaction T G1, G2, . . . , Gn , and execution thereof is then started using multi-operation processing (S 206 ). 
     [(7) Detecting Access Area of Tasks] 
     Using the indices of the relation that tasks t 1 , t 2 , t 3 , . . . , t p  access, certain blocks (stored locations of the blocks) within the blocks b 1 , b 2 , b 3 , . . . , b m  in the relation that tasks t 1 , t 2 , t 3 , . . . , t p  in group G 1  need to access are located and collected into block sets B 1 , B 2 , B 3 , . . . , B p  respectively (S 207 ). 
     In other words, for each task t i  (i=1, 2, 3, . . . , p), a block set B i ={a set of blocks that each task t i  needs to access in the relation S consisting of blocks b 1 , b 2 , . . . , b m }(i=1, 2, 3, . . . , p) is found. In finding such a block set, only the indices of the relation are used to find the stored location of the blocks, and no disk access is carried out to blocks in the relation for locating the stored location of the blocks. 
     [(8) Determining a Block Access Order (S 208 )] 
     Once block sets B 1 , B 2 , B 3 , . . . , B p  corresponding to the tasks t 1 , t 2 , t 3 , . . . , t p  in group G 1  are found, the union of block sets B 1 , B 2 , B 3 , . . . , B p  is obtained. First, the union of the block sets corresponding to tasks t 1  and t 2  is obtained, then the union of that union and block set B 3  corresponding to task t 3  is obtained. This is repeated successively, where finally the union of the last union and block set B p  corresponding to task t p  is obtained. 
     In obtaining each union, the blocks to be added into the union successively are inserted at the end of the union. Then, the last obtained union helps determine a block access order specifying which block to be accessed first and which block to be accessed last in the relation for executing the tasks, which are partial operations of the transactions, in the transaction execution order (S 208 ). 
     The reason for obtaining the union in this manner is to allow the blocks to be accessed only once from the disk instead of accessing the blocks many times from the disk to read the blocks in the relation required for executing the tasks in the group. 
     [(9) Executing Tasks for Each Block (S 209 )] 
     [Executing Tasks For Block b j ] 
     According to the determined block access order, the first block to be accessed in the relation is expressed as b j  (1≦j≦m). In order to check if the tasks t 1 , t 2 , t 3 , . . . , t p  in the group G 1  need to be executed for block b j , block b j  is expressed as a set {b j } and the intersections (∩) of set {b j } and the block sets B 1 , B 2 , B 3 , . . . , B p  corresponding to the tasks t 1 , t 2 , t 3 , . . . , t p  are obtained. All of the tasks corresponding to the block sets of which intersection became {b j } are executed for block b j , and the tasks corresponding to the block sets of which intersection became an empty set ({ }) are not executed for block b j . 
     Furthermore, when some tasks need to process the same data item in block b j , the task operations, which are partial operations of the transactions, are executed consecutively on the data item according to the transaction execution order indicated in the precedence graph. 
     Once all of the tasks in group G 1  requiring to be executed for block b j  are executed, block b j  is no longer needed to be accessed again. Therefore, the differences of the block sets of which intersection became {b j } and set {b j } are obtained and the obtained differences are expressed as block sets B i   (1)  (i=1, 2, . . . , p); the tasks corresponding to the block sets of which difference became an empty set ({ }) are finished (S 210 ), and the tasks corresponding to the block sets of which difference did not become an empty set are not finished. 
     [End and Commit Transaction] 
     Once some task execution is finished at block b j , check whether the transaction containing the finished task is ended (S 211 ). When the execution of all of the tasks contained in the transaction is finished (S 211 : YES), the transaction is ended. 
     Once the transaction is ended, whether the ended transaction can be committed at this time is determined based on the precedence graph (S 212 ). When an incoming edge exists to the vertex of the ended transaction (S 212 : NO), the transaction is not committed and is left as a commit-waiting transaction (S 216 ). 
     If there is no incoming edge to the vertex of the ended transaction (S 212 : YES), the transaction is committed (S 213 ). Once the transaction is committed, the vertex of the transaction and all of the outgoing edges from the vertex are removed from the precedence graph (S 214 ). 
     In doing so, if removing the edges causes the vertices of some other commit-waiting transactions to lose all of their incoming edges (S 215 : YES), these commit-waiting transactions are also committed (S 213 ). 
     The reason for this is that, if the vertices have no incoming edges, a transaction that previously wrote to the same data item is already committed; therefore, other transactions reading the written data item may also be committed. 
     [Task Processing for Block b k ] 
     On the other hand, if all of the blocks are not accessed yet (S 217 : NO), by returning to S 209 , the next block b k  (1≦k≦m) is read in the block access order and block b k  is expressed as a set {b k }, and the intersections of the block sets corresponding to the tasks in the group, excluding the tasks already executed, and set {b k } are obtained. The tasks corresponding to the block sets of which intersection became {b k } are then executed for block b k . 
     Once all of the tasks in group G 1  requiring to be executed for block b k  are executed, block b k  is no longer needed to be accessed again. Therefore, the differences of block sets B i   (1)  (the block sets obtained from the last differences after executing for block b j ) and set {b k } are obtained. The obtained differences are then expressed as blocks sets B i   (2)  (i=1, 2, . . . , n); the tasks corresponding to the block set of which difference became an empty set ({ }) are finished, and the tasks corresponding to the block set of which difference did not become an empty set are not finish yet. 
     [End and Commit Transaction] 
     Once some task execution is finished at block b k  (S 210 ), whether the transaction containing the finished task is ended is checked (S 211 ). When the execution of all of the tasks contained in the transaction is finished, the transaction is ended. Once the transaction is ended, determine whether the transaction can be committed at this time based on the precedence graph (S 212 ). 
     When an incoming edge exists in the vertex of the ended transaction (S 212 : NO), the transaction is not committed and is left as a commit-waiting transaction (S 216 ). 
     If no incoming edge exists in the vertex of the ended transaction (S 212 : YES), the transaction is committed (S 213 ). Once the transaction is committed, the vertex of the transaction and all of the outgoing edges from the vertex are removed from the precedence graph. 
     By repeating the steps described above, the rest of the blocks are accessed in the block access order and the remaining tasks in the group are executed for the accessed blocks. As a result, the execution of all of the tasks in group G 1  is finished (S 217 : YES). 
     [(10) Executing Groups G 2 , . . . , Gn Using Multi-Operation Processing] 
     Once the execution of group G 1  is finished (S 218 ), the remaining groups G 2 , . . . , Gn are retrieved successively from the synthetic transaction T G1, G2, . . . , Gn  and then executed using the same technique used for executing group G 1  (S 219 : NO). 
     Once all of the groups are executed (S 219 : YES), the execution of the synthetic transaction T G1,G2, . . . , Gn  is completed. Therefore, all of the submitted transactions T 1 , T 2 , T 3 , . . . , T s  are executed and committed (S 220 ). 
     1.2. Examples of Multi-Operation Processing Providing Concurrency Control of Transactions 
     The steps of multi-operation processing providing concurrency control of transactions given in Section 1.1 are described in detail using the following specific examples. 
       FIG. 3-1  shows a database relation DEPARTMENT ( 300 ) created using a fixed length record: the relation DEPARTMENT ( 300 ) stores 25 records in 5 blocks; each block has 5 records; each record stores data containing attributes DNUMBER (department number), DNAME (department name), MGRSSN (manager salaried staff number), BUDGET, and DPHONE (department phone number); and each block has a block pointer pointing to the next block. A primary key DNUMBER has a primary index ( 310 ) and the primary index ( 310 ) has an index pointer pointing to each block. Also, attribute DPHONE has a secondary index ( 321 , 322 ), and the secondary index ( 321 , 322 ) has an index pointer pointing to each record. 
     A database relation EMPLOYEE of  FIG. 3-2  is created using a fixed length record: the relation EMPLOYEE ( 400 ) stores 20 records in 5 blocks; each block has 4 records; each record stores data containing attributes SSN (salaried staff number), FNAME (first name), MINIT (middle name initial), LNAME (last name), BDATE (birth date), DNUM (department number), and PHONE (phone number); and each block has a block pointer pointing to the next block. A primary key SSN has a primary index ( 410 ) and the primary index ( 410 ) has an index pointer pointing to each block. Also attribute PHONE has a secondary index ( 420 ), and the secondary index ( 420 ) has an index pointer pointing to each record. 
     In addition to the relation DEPARTMENT ( 300 ) of  FIG. 3-1  and the relation EMPLOYEE ( 400 ) of  FIG. 3-2 , there is another relation PROJECT which is not shown as a diagram in the database. The relations DEPARTMENT ( 300 ), EMPLOYEE ( 400 ), and PROJECT are access areas of the relational database system, where the blocks in the relations are access units on disk in which data of the database is stored. 
     Next, in order to discuss multi-operation processing providing concurrency control of transactions, execution of the following transactions T 1 , T 2 , T 3 , T 4 , T 5 , T 6 , T 7 , T 8  to perform their operations to the relations mentioned above is described. 
     In the following example, each transaction starts with a statement BEGIN WORK and ends with a statement COMMIT WORK. 
     (T 1 ):BEGIN WORK;
         Update Operation 1 of T 1      UPDATE DEPARTMENT   SET BUDGET=BUDGET+10000   WHERE DNUMBER=7;   Update Operation 2 of T 1      UPDATE DEPARTMENT   SET BUDGET=BUDGET+20000   WHERE DNUMBER=9;   Update Operation 3 of T 1      UPDATE EMPLOYEE   SET DNUM=4   WHERE SSN=2411111133;   COMMIT WORK;       

     (T 2 ):BEGIN WORK;
         Update Operation 1 of T 2      UPDATE DEPARTMENT   SET BUDGET=BUDGET+22000   WHERE DPHONE=23-3728;   Update Operation 2 of T 2      UPDATE DEPARTMENT   SET BUDGET=BUDGET+30000   WHERE DNUMBER&gt;6 AND DNUMBER&lt;9;   COMMIT WORK;       

     (T 3 ):BEGIN WORK;
         Update Operation 1 of T 3      UPDATE DEPARTMENT   SET MGRSSN=470124116   WHERE DNUMBER=6 OR DNUMBER=19;   Retrieve Operation 1 of T 3      SELECT DNUMBER, DNAME   FROM DEPARTMENT   WHERE DNUMBER=19;   COMMIT WORK;       

     (T 4 ):BEGIN WORK;
         Update Operation 1 of T 4      UPDATE DEPARTMENT   SET DPHONE=23-3736   WHERE DNUMBER=3;   Update Operation 2 of T 4      UPDATE DEPARTMENT   SET DPHONE=23-3737   WHERE DNUMBER=19;   Update Operation 3 of T 4      UPDATE EMPLOYEE   SET BDATE=‘DEC-27-1971’   WHERE SSN=2066567788;   COMMIT WORK;       

     (T 5 ):BEGIN WORK;
         Update Operation 1 of T 5      UPDATE DEPARTMENT   SET BUDGET=BUDGET−24000   WHERE DNUMBER=7 OR DNUMBER=8;   Update Operation 2 of T 5      UPDATE DEPARTMENT   SET BUDGET=BUDGET−11000   WHERE DNUMBER=14;   COMMIT WORK;       

     (T 6 ):BEGIN WORK;
         Update Operation 1 of T 6      UPDATE DEPARTMENT   SET BUDGET=BUDGET−15000   WHERE DNUMBER=3 OR DNUMBER=14;   Update Operation 2 of T 6      UPDATE DEPARTMENT   SET MGRSSN=433-424659   WHERE DNUMBER=22;   Retrieve Operation 3 of T 6      SELECT*   FROM DEPARTMENT   WHERE DNUMBER=23;   COMMIT WORK;       

     (T 7 ):BEGIN WORK;
         Update Operation 1 of T 7      UPDATE EMPLOYEE   SET BDATE=‘DEC-27-1971’   WHERE SSN=1645455566;   COMMIT WORK;       

     (T S ):BEGIN WORK;
         Update Operation 1 of T S      UPDATE EMPLOYEE   SET DNUM=7   WHERE PHONE=21-3728 OR SSN=2066567788;   COMMIT WORK;
 
[(1) Obtaining Partial Operations of Transactions (S 201 )]
       

     For the submitted transitions T 1 , T 2 , T 3 , T 4 , T 5 , T 6 , T 7 , T 8 , a read operation on a record r performed by each transaction is expressed as read_item(r), and a write operation on a record r performed by each transaction is expressed as write_item(r) to create partial operations of each transaction in the following. A record in the relation DEPARTMENT is expressed as D.ri (i=1, 2, 3, . . . , 25), and a record in the relation EMPLOYEE is expressed as E.ri (i=1, 2, 3, . . . , 20). The stored location of each record is found using the indices of the relations. 
     Each partial operation such as an update operation and a retrieve operation contained in a transaction is expressed as task t i   j  (i denotes transaction number, and j denotes operation number in the transaction). 
     (T 1 ): 
     (t 1   1 ):read_item(D.r 7 );
         D.r 7 .BUDGET:=D.r 7 .BUDGET+10000;   write_item(D.r 7 );       

     (t 1   2 ):read_item(D.r 9 );
         D.r 9 .BUDGET:=D.r 9 .BUDGET+20000;   write_item(D.r 9 );       

     (t 1   3 ):read_item(E.r 14 );
         E.r 14 .DNUM:=4;   write_item(E.r 14 );
 
(T 2 ):
       

     (t 2   1 ):read_item(D.r 7 );
         D.r 7 .BUDGET:=D.r 7 .BUDGET+22000;   write_item(D.r 7 );       

     (t 2   2 ):read_item(D.r 7 );
         D.r 7 .BUDGET:=D.r 7 .BUDGET+30000;   write_item(D.r 7 );   read_item(D.r 8 );   D.r 8 .BUDGET:=D.r 8 .BUDGET+30000;   write_item(D.r 8 );
 
(T 3 ):
       

     (t 3   1 ):read_item(D.r 6 );
         D.r 6 .MGRSSN:=470124116;   write_item(D.r 6 );   read_item(D.r 19 );   D.r 19 .MGRSSN:=470124116;   write_item(D.r 19 );       

     (t 3   2 ):read_item(D.r 19 ); 
     (T 4 ): 
     (t 4   1 ):read_item(D.r 3 );
         D.r 3 .DPHONE:=23-3736;   write_item(D.r 3 );       

     (t 4   2 ):read_item(D.r 19 );
         D.r 19 .DPHONE:=23-3737;   write_item(D.r 19 );       

     (t 4   3 ):read_item(E.r 10 );
         E.r 10 .BDATE:=‘DEC-27-1971’;   write_item(E.r 10 );
 
(T 5 ):
       

     (t 5   1 ):read_item(D.r 7 );
         D.r 7 .BUDGET:=D.r 7 .BUDGET−24000;   write_item(D.r 7 );   read_item(D.r 8 );   D.r 8 .BUDGET:=D.r 8 .BUDGET−24000;   write_item(D.r 8 );       

     (t 5   2 ):read_item(D.r 14 );
         D.r 14 .BUDGET:=D.r 14 .BUDGET−11000;   write_item(D.r 14 );
 
(T 6 ):
       

     (t 6   1 ):read_item(D.r 3 );
         D.r 3 .BUDGET:=D.r 3 .BUDGET−15000;   write_item(D.r 3 );   read_item(D.r 14 );   D.r 14 .BUDGET:=D.r 14 .BUDGET−15000;   write_item(D.r 14 );       

     (t 6   2 ):read_item(D.r 22 );
         D.r 22 .MGRSSN:=433424659;   write_item(D.r 22 );       

     (t 6   3 ):read_item(D.r 23 ); 
     (T 7 ): 
     (t 7   1 ):read_item(E.r 6 );
         E.r 6 .BDATE:=‘DEC-27-1971’;   write_item(E.r 6 );
 
(T 8 ):
       

     (t 8   1 ):read_item(E.r 6 );
         E.r 6 .DNUM:=7;   write_item(E.r 6 );   read_item(E.r 10 );   E.r 10 .DNUM:=7;   write_item(E.r 10 );
 
[(2) Determining a Transaction Execution Order (S 202 )]
       

     Once the partial operations of the transactions are obtained, a transaction execution order for the transactions T 1 , T 2 , T 3 , T 4 , T 5 , T 6 , T 7  and T 8  is determined. 
     In order to determine the transaction execution order, the processing cost of each transaction is obtained based on the partial operations contained in the transaction, and the transactions are sorted in the order from the transaction of smaller processing cost. 
     By obtaining the processing costs of the transactions based on the partial operations of the transactions, the following table can be obtained. 
     
       
         
           
               
               
             
               
                   
                 TABLE 1 
               
             
            
               
                   
                   
               
               
                   
                 Transaction 
               
            
           
           
               
               
               
               
               
               
               
               
               
            
               
                   
                 T 1   
                 T 2   
                 T 3   
                 T 4   
                 T 5   
                 T 6   
                 T 7   
                 T 8   
               
               
                   
                   
               
            
           
           
               
               
               
               
               
               
               
               
               
            
               
                 Processing Cost 
                 2 
                 1 
                 2 
                 3 
                 2 
                 3 
                 1 
                 2 
               
               
                   
               
            
           
         
       
     
     The processing cost of a transaction is the number of block accesses required for executing the transaction. 
     For example, transaction T 1  needs to access records r 7  and r 9  stored in block b 2  in the relation DEPARTMENT and record r 14  stored in block b 4  in the relation EMPLOYEE, thus two block accesses are required; therefore, the processing cost of transaction T 1  is 2. 
     Once the processing costs of the transactions are obtained, the transaction execution order may be determined as T 2 , T 7 , T 3 , T 1 , T 5 , T 8 , T 4 , T 6  by sorting the transactions in the order from the transaction of smaller processing cost as follows. Here, sort ( . . . ) means ordering the transactions in the order from the transaction of smaller processing cost. 
     sort (T 1 , T 2 , T 3 , T 4 , T 5 , T 6 , T 7 , T 8 )→(T 2 , T 7 , T 1 , T 3 , T 5 , T 8 , T 4 , T 6 ) 
     [(3) Creating a Precedence Graph (S 203 )] 
     Once the transaction execution order is determined, the precedence graph shown in  FIG. 4(   a ) having the transactions T 2 , T 7 , T 1 , T 3 , T 5 , T 8 , T 4  and T 6  as vertices is created. In creating the precedence graph, when some transactions within the transactions T 2 , T 7 , T 1 , T 3 , T 5 , T 8 , T 4  and T 6  need to process the same data item, a directed edge is created for the data item and is drawn from the vertex of the first transaction to perform its operation to the vertex of the subsequent transaction to perform its operation to clarify the transaction execution order for the data item. 
     If a data item is to be processed by only a single transaction, no edges are created for the data item in the precedence graph. 
     Since transactions T 4  and T 6  perform their update operations on the same record D.r 3  in the relation DEPARTMENT, an edge is drawn from vertex T 4  to vertex T 6  according to the transaction execution order. 
     Since transactions T 2 , T 1 , and T 5  perform their update operations on the same record D.r 7  in the relation DEPARTMENT, an edge is drawn from vertex T 2  to vertex T 1 , and another edge is drawn from vertex T 1  to vertex T 5  according to the transaction execution order. 
     Since transactions T 2  and T 5  perform their update operations on the same record D.r 8  in the relation DEPARTMENT, an edge is drawn from vertex T 2  to vertex T 5  according to the transaction execution order. 
     Since transactions T 5  and T 6  perform their update operations on the same record D.r 14  in the relation DEPARTMENT, an edge is drawn from vertex T 5  to vertex T 6  according to the transaction execution order. 
     Since transactions T 3  and T 4  perform their update operations on the same record D.r 19  in the relation DEPARTMENT, an edge is drawn from vertex T 3  to vertex T 4  according to the transaction execution order. 
     Since transactions T 7  and T 8  perform their update operations on the same record E.r 6  in the relation EMPLOYEE, an edge is drawn from vertex T 7  to vertex T 8  according to the transaction execution order. 
     Since transactions T 8  and T 4  perform their update operations on the same record E.r 10  in the relation EMPLOYEE, an edge is drawn from vertex T 8  to vertex T 4  according to the transaction execution order. 
     Because the precedence graph shown in  FIG. 4(   a ) is created based on the transaction execution order determined at the beginning, there are no cycles in the precedence graph. Therefore, any transaction schedule derived from this precedence graph is a serializable schedule. 
     [(4) Grouping Tasks (S 204 )] 
     Tasks t 2   1 , t 2   2 , t 7   1 , t 1   1 , t 1   2 , t 1   3 , t 3   1 , t 3   2 , t 5   1 , t 5   2 , t 8   1 , t 4   1 , t 4   2 , t 4   3 , t 6   1 , t 6   2  and t 6   3 , which are partial operations of the transactions T 2 , T 7 , T 1 , T 3 , T 5 , T 8 , T 4  and T 6 , are retrieved from the transactions and divided into groups for each database relation, and the tasks collected into groups are lined up in the transaction execution order as follows. 
     
       
         
           
               
               
               
             
               
                   
               
             
            
               
                   
                 DEPARTMENT: 
                 Group G1 = {t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 3   2 , 
               
               
                   
                   
                 t 5   1 , t 5   2 , t 4   1 , t 4   2 , t 6   1 , t 6   2 , t 6   3 } 
               
               
                   
                 EMPLOYEE: 
                 Group G2 = {t 7   1 , t 1   3 , t 8   1 , t 4   3 } 
               
               
                   
               
            
           
         
       
     
     The tasks to be performed for the relation DEPARTMENT are collected into group G 1 . 
     The tasks to be performed for the relation EMPLOYEE are collected into group G 2 . 
     [(5) Creating (S 205 ) and Executing (S 206 ) Synthetic Transaction T G1,G2 ] 
     Once the tasks are divided and the groups G 1  and G 2  are created, a synthetic transaction T G1,G2  is created using the created groups G 1  and G 2 . 
     In order to execute the synthetic transaction T G1,G2 , the groups G 1  and G 2  contained in the synthetic transaction T G1,G2  are executed respectively using multi-operation processing. 
     [(5-1) Processing Group G] 
     [(a) Obtaining Block Sets to be Accessed by Tasks (S 207 )] 
     Using the primary index ( 310 ) and the secondary index ( 321 , 322 ) of the relation DEPARTMENT ( 300 ) shown in  FIG. 3-1 , the blocks in the relation DEPARTMENT ( 300 ) that the tasks in the group G 1  need to read are found and collected into block sets B 2   1 , B 2   2 , B 1   1 , B 1   2 , B 3   1 , B 3   2 , B 5   1 , B 5   2 , B 4   1 , B 4   2 , B 6   1 , B 6   2 , B 6   3  corresponding to the tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 3   2 , t 5   1 , t 5   2 , t 4   1 , t 4   2 , t 6   1 , t 6   2 , t 6   3 , respectively as follows. 
     In finding the block sets, only the indices of the relation are used to find the stored location of the blocks; thus, no disk access is carried out to blocks in the relation to locate the stored locations of the blocks. 
                                                For task t 2   1 :   B 2   1  = {b 2 }           For task t 2   2 :   B 2   2  = {b 2 }           For task t 1   1 :   B 1   1  = {b 2 }           For task t 1   2 :   B 1   2  = {b 2 }           For task t 3   1 :   B 3   1  = {b 2 , b 4 }           For task t 3   2 :   B 3   2  = {b 4 }           For task t 5   1 :   B 5   1  = {b 2 }           For task t 5   2 :   B 5   2  = {b 3 }           For task t 4   1 :   B 4   1  = {b 1 }           For task t 4   2 :   B 4   2  = {b 4 }           For task t 6   1 :    B 6   1  = {b 1 , b 3 }           For task t 6   2 :   B 6   2  = {b 5 }           For task t 6   3 :   B 6   3  = {b 5 }                        
[(b) Determining a Block Access Order (S 208 )]
 
     Once the block sets corresponding to the tasks in the group are obtained, the union of the block sets is obtained in the lined up order of the tasks in the group, that is, in the order of the tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 3   2 , t 5   1 , t 5   2 , t 4   1 , t 4   2 , t 6   1 , t 6   2 , t 6   3 , respectively. 
     First, empty set TB 0 ={ } is prepared, and the union of the empty set TB 0  and block set B 2   1  corresponding to task t 2   1  is obtained to create a set TB 2   1 . Next, the union of set TB 2   1  and block set B 2   2  corresponding to task t 2   2  is obtained to create a set TB 2   2 . Similarly, the union of block sets B 1   1 , B 1   2 , B 3   1 , B 3   2 , B 5   1 , B 5   2 , B 4   1 , B 4   2 , B 6   1 , B 6   2  and B 6   3  corresponding to tasks t 1   1 , t 1   2 , t 3   1 , t 3   2 , t 5   1 , t 5   2 , t 4   1 , t 4   2 , t 6   1 , t 6   2 , and t 6   3  are obtained to create sets TB 1   1 , TB 1   2 , TB 3   1 , TB 3   2 , TB 5   1 , TB 5   2 , TB 4   1 , TB 4   2 , TB 6   1 , TB 6   2  and TB 6   3 , respectively, resulting in the following. In this case, the blocks to be added into the union are inserted at the end of the union. 
     
       
         
           
               
               
             
               
                   
               
             
            
               
                   
                 TB 0  ← { } (empty set) 
               
            
           
           
               
               
               
            
               
                 Union with block set B 2   1 : 
                 TB 2   1  ← TB 0  U B 2   1 , 
                 TB 2   1  = {b 2 } 
               
               
                 Union with block set B 2   2 : 
                 TB 2   2  ← TB 2   1  U B 2   2 , 
                 TB 2   2  = {b 2 } 
               
               
                 Union with block set B 1   1 : 
                 TB 1   1  ← TB 2   2  U B 1   1 , 
                 TB 1   1  = {b 2 } 
               
               
                 Union with block set B 1   2 : 
                 TB 1   2  ← TB 1   1  U B 1   2 , 
                 TB 1   2  = {b 2 } 
               
               
                 Union with block set B 3   1 : 
                 TB 3   1  ← TB 1   2  U B 3   1 , 
                 TB 3   1  = {b 2 , b 4 } 
               
               
                 Union with block set B 3   2 : 
                 TB 3   2  ← TB 3   1  U B 3   2 , 
                 TB 3   2  = {b 2 , b 4 } 
               
               
                 Union with block set B 5   1 : 
                 TB 5   1  ← TB 3   2  U B 5   1 , 
                 TB 5   1  = {b 2 , b 4 } 
               
               
                 Union with block set B 5   2 :  
                 TB 5   2  ← TB 5   1  U B 5   2 , 
                 TB 5   2  = {b 2 , b 4 , b 3 } 
               
               
                 Union with block set B 4   1 : 
                 TB 4   1  ← TB 5   2  U B 4   1 , 
                 TB 4   1  = {b 2 , b 4 , b 3 , b 1 } 
               
               
                 Union with block set B 4   2 :  
                 TB 4   2  ← TB 4   1  U B 4   2 , 
                 TB 4   2  = {b 2 , b 4 , b 3 , b 1 } 
               
               
                 Union with block set B 6   1 :  
                 TB 6   1  ← TB 4   2  U B 6   1 , 
                 TB 6   1  = {b 2 , b 4 , b 3 , b 1 } 
               
               
                 Union with block set B 6   2 : 
                 TB 6   2  ← TB 6   1  U B 6   2 , 
                 TB 6   2  = {b 2 , b 4 , b 3 , b 1 , b 5 } 
               
               
                 Union with block set B 6   3 :  
                 TB 6   3  ← TB 6   2  U B 6   3 , 
                 TB 6   3  = {b 2 , b 4 , b 3 , b 1 , b 5 } 
               
               
                   
               
            
           
         
       
     
     When the union of the block sets is obtained respectively in the lined up order of the tasks as above, the block access can begin at block b 2  and end at block b 5  from the last obtained union set TB 6   3 . Therefore, the access order for blocks in the relation DEPARTMENT ( 300 ) is determined as (b 2 , b 4 , b 3 , b 1 , b 5 ). 
     By using this method to obtain the union of the block sets, the access order for blocks in the relation DEPARTMENT is determined. Then each block can be read in this order, and tasks accessing the read block are extracted from the group and executed, respectively. 
     [(c) Executing Tasks for Each Block (S 209 )] 
     [(c-1) Accessing Block b 2 ] 
     First, the data of block b 2  at stored location 256 in the relation DEPARTMENT is read into the main memory from the disk. In order to check if tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 3   2 , t 5   1 , t 5   2 , t 4   1 , t 4   2 , t 6   1 , t 6   2  and t 6   3  in group G 1  need to be executed for block b 2 , block b 2  is expressed as a set {b 2 }, and the intersections of block sets B 2   1 , B 2   2 , B 1   1 , B 1   2 , B 3   1 , B 3   2 , B 5   1 , B 5   2 , B 4   1 , B 4   2 , B 6   1 , B 6   2 , B 6   3  and set {b 2 } are obtained, resulting in the following. 
     
       
         
           
               
               
               
             
               
                   
                   
               
             
            
               
                   
                 For task t 2   1 : 
                 B 2   1  ∩ {b 2 } = {b 2 } 
               
               
                   
                 For task t 2   2 : 
                 B 2   2  ∩ {b 2 } = {b 2 } 
               
               
                   
                 For task t 1   1 : 
                 B 1   1  ∩ {b 2 } = {b 2 } 
               
               
                   
                 For task t 1   2 : 
                 B 1   2  ∩ {b 2 } = {b 2 } 
               
               
                   
                 For task t 3   1 : 
                 B 3   1  ∩ {b 2 } = {b 2 } 
               
               
                   
                 For task t 3   2 : 
                 B 3   2  ∩ {b 2 } = { } 
               
               
                   
                 For task t 5   1 : 
                 B 5   1  ∩ {b 2 } = {b 2 } 
               
               
                   
                 For task t 5   2 : 
                 B 5   2  ∩ {b 2 } = { } 
               
               
                   
                 For task t 4   1 : 
                 B 4   1  ∩ {b 2 } = { } 
               
               
                   
                 For task t 4   2 : 
                 B 4   2  ∩ {b 2 } = { } 
               
               
                   
                 For task t 6   1 : 
                 B 6   1  ∩ {b 2 } = { } 
               
               
                   
                 For task t 6   2 : 
                 B 6   2  ∩ {b 2 } = { } 
               
               
                   
                 For task t 6   3 : 
                 B 6   3  ∩ {b 2 } = { } 
               
               
                   
                   
               
            
           
         
       
     
     Since the intersections for tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 5   1  became {b 2 }, the tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 5   1  are executed for block b 2  read into the main memory. 
     For executing the tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 5   1 , the records in the block are processed from the record of smaller record number, and for each record, some of the task operations are executed consecutively on the record in the lined up order of the tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 5   1  respectively, resulting in the following. 
     
       
         
           
               
             
               
                 TABLE 2 
               
               
                   
               
               
                 Task operations for block b 2  in relation DEPARTMENT 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
            
               
                   
                 read_item(D.r6); 
                 Time  
               
               
                 t 3   1  updates 
                 D.r6.MGRSSN := 470124116; 
                 ↓ 
               
               
                   
                 write_item(D.r6); 
                   
               
               
                   
                 read_item(D.r7); 
                   
               
               
                 t 2   1  updates 
                 D.r7.BUDGET := D.r7.BUDGET + 22000; 
                   
               
               
                 t 2   2  updates 
                 D.r7.BUDGET := D.r7.BUDGET + 30000; 
                   
               
               
                 t 1   1  updates 
                 D.r7.BUDGET := D.r7.BUDGET + 10000; 
                   
               
               
                 t 5   1  updates 
                 D.r7.BUDGET := D.r7.BUDGET − 24000; 
                   
               
               
                   
                 write_item(D.r7); 
                   
               
               
                   
                 read_item(D.r8); 
                   
               
               
                 t 2   2  updates 
                 D.r8.BUDGET := D.r8.BUDGET + 30000; 
                   
               
               
                 t 5   1  updates 
                 D.r8.BUDGET := D.r8.BUDGET − 24000; 
                   
               
               
                   
                 write_item(D.r8); 
                   
               
               
                   
                 read_item(D.r9); 
                   
               
               
                 t 1   2  updates 
                 D.r9.BUDGET := D.r9.BUDGET + 20000; 
                   
               
               
                   
                 write_item(D.r9); 
                   
               
               
                   
                 commit(T 2 ); 
               
               
                   
               
            
           
         
       
     
     Since record D.r 6  is the smallest record number in this case, the update operation of task t 3   1  is executed on record D.r 6  first. 
     The update operations of tasks t 2   1 , t 2   2 , t 1   1 , and t 5   1 , which are partial operations of transactions T 2 , T 1 , and T 5 , are executed consecutively on record D.r 7  according to the transaction execution order T 2 , T 1 , T 5  indicated in the precedence graph of  FIG. 4(   a ). 
     Task t 2   1  updates the value of record D.r 7  read from the database; 
     task t 2   2  updates the value of record D.r 7  updated by task t 2   1 ; 
     task t 1   1  updates the value of record D.r 7  updated by task t 2   2  and 
     task t 5   1  updates the value of record D.r 7  updated by task t 1   1 . 
     In this manner, the update operations of tasks t 2   1 , t 2   2 , t 1   1 , and t 5   1  are executed consecutively on record D.r 7  in the main memory, and only the last updated result by task t 5   1  is written in the database once. 
     The update operations of tasks t 2   2  and t 5   1 , which are partial operations of transactions T 2  and T 5 , are executed consecutively on record D.r 8  according to the transaction execution order T 2 , T 5  indicated in the precedence graph of  FIG. 4(   a ). 
     Task t 2   2  updates the value of record D.r 8  read from database; and 
     task t 5   1  updates the value of record D.r 8  updated by task t 2   2 . 
     In this manner, the update operations of tasks t 2   2  and t 5   1  are executed consecutively on record D.r 8  in the main memory, and only the last updated result by task t 5   1  is written in the database once. 
     For record D.r 9 , task t 1   2  updates the value of record D.r 9  read from database. 
     Once the tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 5   1  for block b 2  are executed, block b 2  is no longer needed to be accessed again; therefore, the differences of block sets B 2   1 , B 2   2 , B 1   1 , B 1   2 , B 3   1 , B 5   1  and set {b 2 } are obtained, and the obtained differences are expressed as block sets B 2   1(1) , B 2   2(1) , B 1   1(1) , B 1   2(1) , B 3   1(1) , and B 5   1(1) , respectively, resulting in the following. 
     
       
         
           
               
               
               
               
             
               
                   
                   
               
             
            
               
                   
                 For task t 2   1 : 
                 B 2   1(1)  ← B 2   1  − {b 2 }, 
                 B 2   1(1)  = { } 
               
               
                   
                 For task t 2   2 : 
                 B 2   2(1)  ← B 2   2  − {b 2 }, 
                 B 2   2(1)  = { } 
               
               
                   
                 For task t 1   1 : 
                 B 1   1(1)  ← B 1   1  − {b 2 }, 
                 B 1   1(1)  = { } 
               
               
                   
                 For task t 1   2 : 
                 B 1   2(1)  ← B 1   2  − {b 2 }, 
                 B 1   2(1)  = { } 
               
               
                   
                 For task t 3   1 : 
                 B 3   1(1)  ← B 3   1  − {b 2 }, 
                 B 3   1(1)  = {b 4 } 
               
               
                   
                 For task t 5   1 : 
                 B 5   1(1)  ← B 5   1  − {b 2 }, 
                 B 5   1(1)  = { } 
               
               
                   
                   
               
            
           
         
       
     
     Since block sets B 2   1(1) , B 2   2(1) , B 1   1(1) , B 1   2(1)  and B 5   1(1)  became an empty set { }, the execution of tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 5   1  is finished. As a result, the execution of all of the tasks in transaction T 2  is finished. Therefore, whether transaction T 2  can be committed at this time is determined based on the precedence graph of  FIG. 4(   a ). Since vertex T 2  does not have any incoming edges from other vertices, transaction T 2  is committed. Once transaction T 2  is committed, vertex T 2  and all of the outgoing edges from vertex T 2  are removed from the precedence graph of  FIG. 4(   a ). The result from this operation is shown in the precedence graph of  FIG. 4(   b ). 
     Also, the edge for record D.r 7  drawn from vertex T 1  to vertex T 5  is left as a dotted line edge in  FIG. 4(   b ) because transactions T 1  and T 5  are not committed yet even though they have finished their update operations on record D.r 7 . 
     [(c-2) Accessing Block b 4 ] 
     Next, the data of block b 4  at stored location 768 in the relation DEPARTMENT is read into the main memory from the disk. In order to check if tasks t 3   1 , t 3   2 , t 5   2 , t 4   1 , t 4   2 , t 6   1 , t 6   2  and t 6   3  in the group, excluding tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 5   1  already executed, needs to be executed for block b 4 , block b 4  is expressed as a set {b 4 }, and the intersections of block sets B 3   1(1) , B 3   2 , B 5   2 , B 4   1 , B 4   2 , B 6   1 , B 6   2 , B 6   3  and set {b 4 } are obtained, resulting in the following. 
     
       
         
           
               
               
               
             
               
                   
                   
               
             
            
               
                   
                 For task t 3   1 : 
                 B 3   1(1)  ∩ {b 4 } = {b4} 
               
               
                   
                 For task t 3   2 : 
                 B 3   2  ∩ {b 4 } = {b 4 } 
               
               
                   
                 For task t 5   2 : 
                 B 5   2  ∩ {b 4 } = { } 
               
               
                   
                 For task t 4   1 : 
                 B 4   1  ∩ {b 4 } = { } 
               
               
                   
                 For task t 4   2 : 
                 B 4   2  ∩ {b 4 } = {b 4 } 
               
               
                   
                 For task t 6   1 : 
                 B 6   1  ∩ {b 4 } = { } 
               
               
                   
                 For task t 6   2 : 
                 B 6   2  ∩ {b 4 } = { } 
               
               
                   
                 For task t 6   3 : 
                 B 6   3  ∩ {b 4 } = { } 
               
               
                   
                   
               
            
           
         
       
     
     Since the intersections for tasks t 3   1 , t 3   2  and t 4   2  became {b 4 }, tasks t 3   1 , t 3   2  and t 4   2  are executed for block b 4 , which is read into the main memory, resulting in the following. 
     
       
         
           
               
             
               
                 TABLE 3 
               
               
                   
               
               
                 Task operations for block b 4  in relation DEPARTMENT 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
            
               
                   
                   
                 read_item(D.r19); 
                 Time  
               
               
                   
                 t 3   1  updates 
                 D.r19.MGRSSN := 470124116; 
                 ↓ 
               
               
                   
                 t 4   2  updates 
                 D.r19.DPHONE := 23-3737; 
                   
               
               
                   
                   
                 write_item(D.r19); 
                   
               
               
                   
                   
                 commit(T 3 ); 
               
               
                   
               
            
           
         
       
     
     The update operations of tasks t 3   1  and t 4   2 , which are partial operations of transactions T 3  and T 4 , are executed consecutively on record D.r 19  according to the transaction execution order T 3 , T 4  indicated in the precedence graph of  FIG. 4(   b ). 
     Task t 3   1  updates the value of record D.r 19  read from the database; and task t 4   2  updates the value of record D.r 19  updated by task t 3   1 . 
     In this manner, the update operations of tasks t 3   1  and t 4   2  are executed consecutively on record D.r 19  in the main memory, and only the last updated result by task t 4   2  is written in the database once. 
     The retrieve operation of task t 3   2  is to retrieve the value of record D.r 19 ; that is, once the update operation of task t 3   1  contained in the same transaction T 5  as task t 3   2  is executed, the value of record D.r 19  updated by task t 3   1  is retrieved as a retrieve result of task t 3   2  before executing the update operation of task t 4   2 . 
     Once the tasks t 3   1 , t 3   2  and t 4   2  for block b 4  are executed, block b 4  is no longer needed to be accessed again; therefore, the differences of block sets B 3   1(1) , B 3   2 , B 4   2  and set {b 4 } are obtained and the obtained differences are expressed as block sets B 3   1(2) , B 3   2(1) , and B 4   2(1) , resulting in the following. 
     
       
         
           
               
               
               
               
             
               
                   
               
             
            
               
                   
                 For task t 3   1 : 
                 B 3   1(2)  ← B 3   1(1)  − {b 4 }, 
                 B 3   1(2)  = { } 
               
               
                   
                 For task t 3   2 : 
                 B 3   2(1)  ← B 3   2  − {b 4 }, 
                 B 3   2(1)  = { } 
               
               
                   
                 For task t 4   2 : 
                 B 4   2(1)  ← B 4   2  − {b 4  }, 
                 B 4   2(1)  = { } 
               
               
                   
               
            
           
         
       
     
     Since block sets B 3   1(2) , B 3   2(1)  and B 4   2(1)  became empty sets ({ }), the execution of tasks t 3   1 , t 3   2  and t 4   2  is finished. As a result, the execution of all of the tasks contained in transaction T 3  is finished. Therefore, whether transaction T 3  can be committed at this time is determined based on the precedence graph of  FIG. 4(   b ). Since vertex T 3  does not have any incoming edges from other vertices, transaction T 3  is committed. 
     Once transaction T 3  is committed, vertex T 3  and all of the outgoing edges from vertex T 3  are removed from the precedence graph of  FIG. 4(   b ). The result of this operation is shown in the precedence graph of  FIG. 4(   c ). 
     [(c-3) Reading Block b 3 ] 
     Next, the data of block b 3  at stored location 512 in the relation DEPARTMENT is read into the main memory from the disk. In order to check if tasks t 5   2 , t 4   1 , t 6   1 , t 6   2  and t 6   3  in the group, excluding tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 3   2 , t 5   1  and t 4   2  already executed, need to be executed for block b 3 , block b 3  is expressed as a set {b 3 }, and the intersections of block sets B 5   2 , B 4   1 , B 6   1 , B 6   2 , B 6   3  and set {b 3 } are obtained, resulting in the following. 
     
       
         
           
               
               
               
             
               
                   
                   
               
             
            
               
                   
                 For task t 5   2 :  
                 B 5   2  ∩ {b 3 } = {b 3 } 
               
               
                   
                 For task t 4   1 : 
                 B 4   1  ∩ {b 3 } = { } 
               
               
                   
                 For task t 6   1 : 
                 B 6   1  ∩ {b 3 } = {b 3 } 
               
               
                   
                 For task t 6   2 : 
                 B 6   2  ∩ {b 3 } = { } 
               
               
                   
                 For task t 6   3 : 
                 B 6   3  ∩ {b 3 } = { } 
               
               
                   
                   
               
            
           
         
       
     
     Since the intersections for tasks t 5   2  and t 6   1  became {b 3 }, tasks t 5   2  and t 6   1  are executed for block b 3 , which is read into the main memory, resulting in the following. 
     
       
         
           
               
             
               
                 TABLE 4 
               
               
                   
               
               
                 Task operations for block b 3  in relation DEPARTMENT 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
            
               
                   
                 read_item(D.r14); 
                 Time  
               
               
                 t 5   2  updates 
                 D.r14.BUDGET := D.r14.BUDGET − 11000; 
                 ↓ 
               
               
                 t 6   1  updates 
                 D.r14.BUDGET := D.r14.BUDGET − 15000; 
                   
               
               
                   
                 write_item(D.r14); 
               
               
                   
               
            
           
         
       
     
     The update operations of tasks t 5   2  and t 6   1 , which are partial operations of transactions T 5  and T 6 , are executed consecutively on record D.r 14  according to the transaction execution order T 5 , T 6  indicated in the precedence graph of  FIG. 4(   c ). 
     Task t 5   2  updates the value of record D.r 14  read from the database; and task t 6   1  updates the value of record D.r 14  updated by task t 5   2 . 
     In this manner, the update operations of tasks t 5   2  and t 6   1  are executed consecutively on record D.r 14  in the main memory, and only the last updated result by task t 6   1  is written in the database once. 
     Once the tasks t 5   2  and t 6   1  for block b 3  are executed, block b 3  is no longer needed to be accessed again; therefore, the differences of block sets B 5   2 , B 6   1  and set {b 3 } are obtained, and the obtained differences are expressed as block sets B 5   2(1)  and B 6   1(1) , resulting in the following. 
     
       
         
           
               
               
               
               
             
               
                   
               
             
            
               
                   
                 For task t 5   2 : 
                 B 5   2(1)  ← B 5   2  − {b 3 }, 
                 B 5   2(1)  = { } 
               
               
                   
                 For task t 6   1 : 
                 B 6   1(1)  ← B 6   1  − {b 3 }, 
                 B 6   1(1)  = {b 1 } 
               
               
                   
               
            
           
         
       
     
     Since block set B 5   2(1)  became an empty set ({ }), the execution of task t 5   2  is finished. 
     Once the execution of task t 5   2  is finished, the execution of all of the tasks in transaction T 5  is finished; therefore, whether transaction T 5  can be committed at this time is determined based on the precedence graph of  FIG. 4(   c ). 
     Since transaction T 5  updated the value of record D.r 7  previously updated by uncommitted transaction T 1 , transaction T 5  cannot be committed yet. Therefore, transaction T 5  is left as a commit-waiting transaction. 
     A non-committing state of transaction T 5  is shown as a dotted line vertex T 5  in the precedence graph of  FIG. 4(   d ) even though the execution of transaction T 5  is finished. 
     Also, the edge for record D.r 14  drawn from vertex T 5  to vertex T 6  is left as a dotted line edge in the precedence graph of  FIG. 4(   d ) because transactions T 5  and T 6  are not committed yet even though they have finished their update operations on record D.r 14 . 
     [(c-4) Accessing Block b 1 ] 
     Next, the data of block b 1  at stored location 0 in the relation DEPARTMENT is read into the main memory from the disk. In order to check if tasks t 4   1 , t 6   1 , t 6   2  and t 6   3  in group G 1 , excluding tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 3   2 , t 5   1 , t 5   2 , and t 4   2  already executed, need to be executed for block b 1 , block b 1  is expressed as a set {b 1 }, and the intersections (∩) of block sets B 4   1 , B 6   1(1) , B 6   2 , B 6   3  and set {b 1 } are obtained, resulting in the following. 
     
       
         
           
               
               
               
             
               
                   
                   
               
             
            
               
                   
                 For task t 4   1 : 
                 B 4   1  ∩ {b1} = {b 1 } 
               
               
                   
                 For task t 6   1 : 
                 B 6   1(1)  ∩ {b 1 } = {b 1 } 
               
               
                   
                 For task t 6   2 : 
                 B 6   2  ∩ {b 1 } = { } 
               
               
                   
                 For task t 6   3 : 
                 B 6   3  ∩ {b 1 } = { } 
               
               
                   
                   
               
            
           
         
       
     
     Since the intersections for tasks t 4   1  and t 6   1  became {b 1 }, tasks t 4   1  and t 6   1  are executed for block b 1 , which is read into the main memory, resulting in the following. 
     
       
         
           
               
             
               
                 TABLE 5 
               
               
                   
               
               
                 Task operations for block b 1  in relation DEPARTMENT 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
            
               
                   
                   
                 read_item(D.r3); 
                 Time  
               
               
                   
                 t 4   1  updates 
                 D.r3.DPHONE := 23-3736; 
                 ↓ 
               
               
                   
                 t 6   1  updates 
                 D.r3.BUDGET := D.r3.BUDGET-15000; 
                   
               
               
                   
                   
                 write_item(D.r3); 
               
               
                   
               
            
           
         
       
     
     The update operations of tasks t 4   1  and t 6   1 , which are partial operations of transactions T 4  and T 6 , are executed consecutively on record D.r 3  according to the transaction execution order T 4 , T 6  indicated in the precedence graph of  FIG. 4(   d ). 
     Task t 4   1  updates the value of record D.r 3  read from the database; and task t 6   1  updates the value of record D.r 3  updated by task t 4   1 . 
     In this manner, the update operations of tasks t 4   1  and t 6   1  are executed consecutively on record D.r 3  in the main memory, and only the last updated result by task t 6   1  is written in the database once. 
     Once the tasks t 4   1  and t 6   1  for block b 1  is executed, block b 1  is no longer needed to be accessed again; therefore, the differences of block sets B 4   1 , B 6   1(1)  and set {b 1 } are obtained, and the obtained differences are expressed as block sets B 4   1(1)  and B 6   1(2) , resulting in the following. 
     
       
         
           
               
               
               
               
             
               
                   
               
             
            
               
                   
                 For task t 4   1 : 
                 B 4   1(1)  ← B 4   1  − {b 1 }, 
                 B 4   1(1)  = { } 
               
               
                   
                 For task t 6   1 : 
                 B 6   1(2)  ← B 6   1(1)  − {b 1 }, 
                 B 6   1(2)  = { } 
               
               
                   
               
            
           
         
       
     
     Since block sets B 4   1(1)  and B 6   1(2)  became empty sets ({ }), the execution of tasks t 4   1  and t 6   1  is finished. 
     Also, the edge for record D.r 3  drawn from vertex T 4  to vertex T 6  is left as a dotted line edge in  FIG. 4(   e ) because transactions T 4  and T 6  are not committed yet even though they have finished their update operations on record D.r 3 . 
     [(c-5) Reading Block b 5 ] 
     Finally, the data of block b 5  at stored location 1024 in the relation DEPARTMENT is read into the main memory from the disk, and the operations of the last tasks t 6   2  and t 6   3  in group G 1  are executed consecutively on block b 5 , resulting in the following. 
     
       
         
           
               
             
               
                 TABLE 6 
               
               
                   
               
               
                 Task operations for block b 5  in relation DEPARTMENT 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
            
               
                   
                   
                 read_item(D.r22); 
                 Time  
               
               
                   
                 t 6   2  updates 
                 D.r22.MGRSSN := 433424659; 
                 ↓ 
               
               
                   
                   
                 write_item(D.r22); 
                   
               
               
                   
                 t 6   3  retrieves 
                 read_item(D.r23); 
               
               
                   
               
            
           
         
       
     
     Task t 6   2  updates the value of record D.r 22  read from the database. 
     Task t 6   3  retrieves the value of record D.r 23  read from the database. 
     Once the execution of tasks t 6   2  and t 6   3  is finished, the execution of all of the tasks in transaction T 6  is finished. Thus, whether transaction T 6  can be committed at this time is determined based on the precedence graph shown in  FIG. 4(   e ). 
     Since transaction T 6  updated the value of record D.r 14  previously updated by uncommitted transaction T 5  and also updated the value of record D.r 3  previously updated by uncommitted transaction T 4 , transaction T 6  cannot be committed. Therefore, transaction T 6  is left as a commit-waiting transaction. 
     A non-committing state of transaction T 6  is shown as a dotted line vertex T 6  in the precedence graph of  FIG. 4(   f ) even though the execution of transaction T 6  is finished. 
     Once the execution of tasks t 6   2  and t 6   3  is finished, the execution of all of the tasks in group G 1  is finished. 
     Once the execution of group G 1  is finished, execution of group G 2  contained in synthetic transaction T G1,G2  is started next. 
     [(5-2) Executing Group G 2 ] 
     Similar to the execution of group G 1 , the execution of group G 2  for the relation EMPLOYEE is performed using multi-operation processing. 
     [(a) Obtaining Block Sets to be Accessed by Tasks] 
     By using the primary index ( 410 ) and the secondary index ( 420 ) of the relation EMPLOYEE ( 400 ) shown in  FIG. 3-2 , the blocks in the relation EMPLOYEE ( 400 ) that need to be read for executing the tasks t 7   1 , t 1   3 , t 5   1  and t 4   3  are located and collected into corresponding block sets B 7   1 , B 1   3 , B 8   1  and B 4   3  respectively, resulting in the following. 
                                                For task t 7   1 :   B 7   1  = {b 2 }           For task t 1   3 :   B 1   3  = {b 4 }           For task t 8   1 :   B 8   1  = {b 2 , b 3 }           For task t 4   3 :   B 4   3  = {b 3 }                        
[(b) Determining a Block Access Order]
 
     Once the block sets are obtained, the union of the block sets corresponding to the respective tasks in the group is obtained in the lined up order of the tasks in the group, that is, in the order of tasks t 7   1 , t 1   3 , t 8   1 , t 4   3  respectively, resulting in the following. 
     
       
         
           
               
               
             
               
                   
               
             
            
               
                   
                 TB 0  ← { } (empty set) 
               
               
                 Union with block set B 7   1 : 
                 TB 7   1  ← TB 0  U B 7   1 , TB 7   1  = {b 2 } 
               
               
                 Union with block set B 1   3 : 
                 TB 1   3  ← TB 7   1  U B 1   3 , TB 1   3  = {b 2 , b 4 } 
               
               
                 Union with block set B 8   1 : 
                 TB 8   1  ← TB 1   3  U B 8   1 , TB 8   1  = {b 2 , b 4 , b 3 } 
               
               
                 Union with block set B 4   3 : 
                 TB 4   3  ← TB 8   1  U B 4   3 , TB 4   3  = {b 2 , b 4 , b 3 } 
               
               
                   
               
            
           
         
       
     
     By obtaining the union of the block sets consecutively as above, the block access can begin at block b 2  and end at block b 3  in the relation EMPLOYEE from the last obtained union TB 4   3 . Thus, the block access order is determined as (b 2 , b 4 , b 3 ). 
     [(c) Task Executions for Each Block] 
     [(c-1) Accessing Block b 2 ] 
     First, the data of block b 2  at stored location 256 in the relation EMPLOYEE ( 400 ) is read into the main memory from the disk. In order to check if tasks t 7   1 , t 1   3 , t 8   1  and t 4   3  in the group need to be executed for block b 2 , block b 2  is expressed as a set {b 2 }, and the intersections of block sets B 7   1 , B 1   3 , B 8   1 , B 4   3  and set {b 2 } are obtained, resulting in the following. 
     
       
         
           
               
               
               
             
               
                   
                   
               
             
            
               
                   
                 For task t 7   1 : 
                 B 7   1  ∩ {b 2 } = {b 2 } 
               
               
                   
                 For task t 1   3 : 
                 B 1   3  ∩ {b 2 } = { } 
               
               
                   
                 For task t 8   1 : 
                 B 8   1  ∩ {b 2 } = {b 2 } 
               
               
                   
                 For task t 4   3 : 
                 B 4   3  ∩ {b 2 } = { } 
               
               
                   
                   
               
            
           
         
       
     
     Since the intersections for tasks t 7   1  and t 8   1  became {b 2 }, tasks t 7   1  and t 8   1  are executed for block b 2 , which is read into the main memory, resulting in the following. 
     
       
         
           
               
             
               
                 TABLE 7 
               
               
                   
               
               
                 Task operations for block b 2  in relation EMPLOYEE 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
            
               
                   
                   
                 read_item(E.r6); 
                 Time  
               
               
                   
                 t 7   1  updates 
                 E.r6.BDATE := ‘DEC-27-1971’; 
                 ↓ 
               
               
                   
                 t 8   1  updates 
                 E.r6.DNUM :=7; 
                   
               
               
                   
                   
                 write_item(E.r6); 
                   
               
               
                   
                   
                 commit(T 7 ); 
               
               
                   
               
            
           
         
       
     
     The update operations of tasks t 7   1  and t 8   1 , which are partial operations of transactions T 7  and T 8 , are executed consecutively on record E.r 6  according to the transaction execution order T 7 , T 8  indicated in the precedence graph of  FIG. 4(   f ). 
     Task t 7   1  updates the value of record E.r 6  read from the database, and task t 8   1  updates the value of record E.r 6  updated by task t 7   1 . 
     In this manner, the update operations of tasks t 7   1  and t 8   1  are executed consecutively on record E.r 6  in the main memory, and only the last updated result by task t 8   1  is written in the database once. 
     Once tasks t 7   1  and t 8   1  for block b 2  are executed, block b 2  is no longer needed to be accessed again; therefore, the differences of block sets B 7   1 , B 8   1  and set {b 2 } are obtained, and the obtained differences are expressed as block sets B 7   1(1)  and B 8   1(1) , resulting in the following. 
     
       
         
           
               
               
               
               
             
               
                   
                   
               
             
            
               
                   
                 For task t 7   1 : 
                 B 7   1(1)  ← B 7   1  − {b 2 }, 
                 B 7   1(1)  = { } 
               
               
                   
                 For task t 8   1 : 
                 B 8   1(1)  ← B 8   1  − {b 2 }, 
                 B 8   1(1)  = {b 3 } 
               
               
                   
                   
               
            
           
         
       
     
     Since block set B 7   1(1)  became an empty set({ }), the execution of task t 7   1  is finished. Once the execution of task t 7   1  is finished, the execution of all of the tasks in transaction T 7  is finished. Therefore, whether transaction T 7  can be committed at this time is determined based on the precedence graph of  FIG. 4(   f ). Since vertex T 7  does not have any incoming edges from other vertices, transaction T 7  is committed. 
     Once transaction T 7  is committed, vertex T 7  and all of the outgoing edges from vertex T 7  are removed from the precedence graph of  FIG. 4(   f ). The result of this operation is shown in the precedence graph of  FIG. 4(   g ). 
     [(c-2) Reading Block b 4 ] 
     Next, the data of block b 4  at stored location 768 in the relation EMPLOYEE ( 400 ) is read into the main memory from the disk. In order to check if tasks t 8   1 , t 1   3  and t 4   3  in the group, excluding task t 7   1  already executed, need to be executed for block b 4 , block b 4  is expressed as a set {b 4 }, and the intersections of block sets B 8   1(1) , B 1   3 , B 4   3  and set {b 4 } are obtained respectively, resulting in the following. 
     
       
         
           
               
               
               
             
               
                   
                   
               
             
            
               
                   
                 For task t 8   1 : 
                 B 8   1(1)  ∩ {b 4 } = { } 
               
               
                   
                 For task t 1   3 : 
                 B 1   3  ∩ {b 4 } = {b 4 } 
               
               
                   
                 For task t 4   3 : 
                 B 4   3  ∩ {b 4 } = { } 
               
               
                   
                   
               
            
           
         
       
     
     Since the intersection for task t 1   3  became {b 4 }, the update operation of task t 1   3  is executed for block b 4 , which is read into the main memory, resulting in the following. 
     
       
         
           
               
             
               
                 TABLE 8 
               
               
                   
               
               
                 Task operation for block b 4  in relation EMPLOYEE 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
            
               
                   
                   
                 read_item(E.r14); 
                 Time  
               
               
                   
                 t 1   3  updates 
                 E.r14.DNUM := 4; 
                 ↓ 
               
               
                   
                   
                 write_item(E.r14); 
                   
               
               
                   
                   
                 commit(T 1 ); 
                   
               
               
                   
                   
                 commit(T 5 ); 
               
               
                   
               
            
           
         
       
     
     Once task t 1   3  for block b 4  is executed, block b 4  is no longer needed to be accessed again. Therefore, the difference of block set B 1   3  and set {b 4 } is obtained, and the obtained difference is expressed as a block set B 1   3(1) , resulting in the following. 
     For task t 1   3 : B 1   3(1) ←B 1   3 -{b 4 }, B 1   3(1) ={ } 
     Since block set B 1   3(1)  became an empty set, the execution of task t 1   3  is finished. 
     Once the execution of task t 1   3  is finished, the execution of all of the tasks in transaction T 1  is finished. Therefore, whether transaction T 1  can be committed at this time is determined based on the precedence graph of  FIG. 4(   g ). 
     Since vertex T 1  does not have any incoming edges from other vertices, transaction T 1  is committed. 
     Once transaction T 1  is committed, vertex T 1  and all of the outgoing edges from the vertex T 1  are removed from the precedence graph of  FIG. 4(   g ). 
     Once, vertex T 1  is removed, the edge drawn from vertex T 1  to vertex T 5  is removed, causing vertex T 5  to lose all of its incoming edges. Therefore, transaction T 5  is also committed. The result of committing transactions T 1  and T 5  is shown in the precedence graph of  FIG. 4(   h ). 
     [(c-3) Accessing Block b 3 ] 
     Finally, the data of block b 3  at stored location 512 in the relation EMPLOYEE is read into the main memory from the disk, and remaining tasks t 8   1  and t 4   3  in group G 2  are executed for block b 3 , resulting in the following. 
     
       
         
           
               
             
               
                 TABLE 9 
               
               
                   
               
               
                 Task operations for block b 3  in relation EMPLOYEE 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
            
               
                   
                   
                 read_item(E.r10); 
                 Time  
               
               
                   
                 t 8   1  updates 
                 E.r10.DNUM := 7; 
                 ↓ 
               
               
                   
                 t 4   3  updates 
                 E.r10.BDATE := ‘DEC-27-1971’; 
                   
               
               
                   
                   
                 write_item(E.r10); 
                   
               
               
                   
                   
                 commit(T 8 ); 
                   
               
               
                   
                   
                 commit(T 4 ); 
                   
               
               
                   
                   
                 commit(T 6 ); 
               
               
                   
               
            
           
         
       
     
     The update operations of tasks t 8   1  and t 4   3 , which are partial operations of transactions T 8  and T 4 , are executed consecutively on record E.r 10  in the transaction execution order T 8 , T 4  indicated in the precedence graph of  FIG. 4(   h ). 
     Task t 8   1  updates the value of record E.r 10  read from database, and task t 4   3  updates the value of record E.r 10  updated by task t 8   1 . 
     In this manner, the update operations of tasks t 8   1  and t 4   3  are executed consecutively on record E.r 10  in the main memory, and only the last updated result by task t 4   3  is written in the database once. 
     Once the execution of tasks t 8   1  and t 4   3  is finished, the execution of all of the tasks in transactions T 8  and T 4  is finished. At this time, vertex T 8  does not have any incoming edges; therefore, transaction T 8  is committed, and subsequently transaction T 4  is also committed. 
     Once vertices T 8  and T 4  are removed from the precedence graph of  FIG. 4(   h ), the edge drawn from vertex T 4  to vertex T 6  is also removed, causing vertex T 6  to lose all of its incoming edges; therefore, transaction T 6  is also committed ( FIG. 4(   i )). 
     As a result, all of the submitted transactions are committed in the order of T 2 , T 3 , T 7 , T 1 , T 5 , T 8 , T 4 , T 6 . 
     The following Table 10 gives a summary of the above. For executing group G 1  for the relation DEPARTMENT ( 300 ): 
     tasks t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1  and t 5   1  are executed for block b 2 , and transaction T 2  is ended and committed; 
     tasks t 3   1 , t 3   2  and t 4   2  are executed for block b 4 , and transaction T 3  is ended and committed; 
     tasks t 5   2  and t 6   1  are executed for block b 3 , and transaction T 5  is ended; 
     tasks t 4   1  and t 6   1  are executed for block b 1 ; and 
     tasks t 6   2  and t 6   3  are executed for block b 5 , and transaction T 6  is ended. 
     For executing group G 2  for the relation EMPLOYEE ( 400 ): 
     tasks t 7   1  and t 8   1  are executed for block b 2 , and transaction T 7  is ended and committed; 
     task t 1   3  is executed for block b 4 , and transaction T 1  is ended and transactions T 1  and T 5  are committed; and 
     tasks t 8   1  and t 4   3  are executed for block b 3 , transactions T 8  and T 4  are ended, and transactions T 8 , T 4  and T 6  are committed. 
     
       
         
           
               
               
               
               
               
             
               
                 TABLE 10 
               
               
                   
               
               
                 RELATION 
                 BLOCK 
                 TASK 
                 END 
                 COMMIT 
               
               
                   
               
             
            
               
                 DEPARTMENT 
                 b 2   
                 t 2   1 , t 2   2 , t 1   1 , t 1   2 , t 3   1 , t 5   1   
                 T 2   
                 T 2   
               
               
                 DEPARTMENT 
                 b 4   
                 t 3   1 , t 3   2 , t 4   2   
                 T 3   
                 T 3   
               
               
                 DEPARTMENT 
                 b 3   
                 t 5   2 , t 6   1   
                 T 5   
                   
               
               
                 DEPARTMENT 
                 b 1   
                 t 4   1 , t 6   1   
                   
                   
               
               
                 DEPARTMENT 
                 b 5   
                 t 6   2 , t 6   3   
                 T 6   
                   
               
               
                 EMPLOYEE 
                 b 2   
                 t 7   1 , t 8   1   
                 T 7   
                 T 7   
               
               
                 EMPLOYEE 
                 b 4   
                 t 1   3   
                 T 1   
                 T 1 , T 5   
               
               
                 EMPLOYEE 
                 b 3   
                 t 8   1 , t 4   3   
                 T 8 , T 4   
                 T 8 , T 4 , T 6   
               
               
                   
               
            
           
         
       
     
     In this manner, the multiple submitted transactions are executed concurrently, and the transactions are ended and they are committed in the order of T 2 , T 3 , T 7 , T 1 , T 5 , T 8 , T 4 , T 6 . The order in which the transactions are committed is a little different from the transaction execution order determined at the beginning; however, both of these orders can be derived from the precedence graph of  FIG. 4(   a ) not containing any cycle in topological sort order. Therefore, this method provides a serializable schedule which is conflict equivalent to the transaction execution order determined at the beginning. 
     As shown above, the transaction processing system of database using multi-operation processing providing concurrency control of transactions is a method that determines a transaction execution order for multiple transactions which can be executed concurrently, creates a precedence graph indicating to update data in the determined transaction execution order, retrieves partial operations contained in the transactions as tasks, collects the retrieved tasks into groups for each database relation in the transaction execution order, creates a synthetic transaction using the groups created by grouping, and executes each group contained in the synthetic transaction using multi-operation processing. 
     In the example described above, records to be processed by a plurality of transactions are treated as data items. However, if records are treated as data items, when a large number of records are processed, the stored location of each record is found and an enormous precedence graph needs to be created. 
     Therefore, a precedence graph may be created for blocks by finding only stored locations of the blocks containing records and treating the blocks as data items. In this case, if a block being accessed exists in the precedence graph, the operations of the tasks in the group are executed consecutively on the block. 
     Also, in the example described above, the transactions including basic update operations such as read and write operations have been dealt with. However, insert and delete operations are also performed in the actual update operations. 
     In order to insert data using multi-operation processing, stored location of a block to insert the data is located, and if the block is found and has enough free space, the data is inserted to the block when the block is accessed in the block access order. 
     Also, in order to delete data using multi-operation processing, stored location of a block including the data to be deleted is located, and if the block is found, the data is deleted from the block when the block is accessed in the block access order. 
     Since each group contained in a synthetic transaction is executed for a different relation, even if the multiple groups contained in the synthetic transaction are executed concurrently, the same data items are not accessed simultaneously by the multiple groups. 
     Also, since the task operations, which are partial operations of the transactions, are executed consecutively on a data item in the block, which is read into the main memory, according to the transaction execution order indicated in the precedence graph, locks are not required by each transaction contained in the synthetic transaction. Therefore, problems such as making transactions wait and aborting transactions do not occur. 
     With the transaction processing system of database using multi-operation processing providing concurrency control of transactions according to the present invention, if a large number of transactions are submitted, a synthetic transaction may be created for these transactions and then executed by the technique described in Section 1.1; once the single synthetic transaction is executed, if a large number of new transactions are submitted, another synthetic transaction may be created for these transactions and then executed by the same technique. Therefore, locks are not required when synthetic transactions are executed serially. Moreover, the multiple groups contained in a synthetic transaction are executed concurrently without causing any deadlocks. 
     Such processing allows significant improvement in the speed of executing multiple transactions. However, there are cases where multiple synthetic transactions should be executed concurrently through assistance of processes ( 104 ) of the operating system of  FIG. 1  so as to efficiently utilize CPU and disk resources ( 105 ). 
     Therefore, a system for executing multiple synthetic transactions concurrently is proposed in Section 2. 
     2. Processing Multiple Synthetic Transactions 
     When new transactions arrive while processing a synthetic transaction, another synthetic transaction is created for the newly arrived transactions. Then, if the new synthetic transaction is executed concurrently with the current synthetic transaction, there is a possibility that data inconsistency may occur between these synthetic transactions. 
     For example, if new transactions T 9 , T 10  and T 11  arrive to the transaction processing system ( 100 ) while processing synthetic transaction T G1,G2 , a synthetic transaction T G3,G4,G5  is created for the transactions T 9 , T 10  and T 11 . 
     If the multi-operation processor ( 102 ) is currently processing synthetic transaction T G1,G2  using process  1  and process  2 , the remaining process  3 , process  4  and process  5  are used to process the synthetic transaction T G3,G4,G5 . 
     Then if both synthetic transaction T G1,G2  and synthetic transaction T G3,G4,G5  need to process the same data item, the same data item may be updated simultaneously so that a data inconsistency may occur. 
     Therefore, in order to solve the problem of multiple synthetic transactions competing for the same data item and causing a data inconsistency to occur, the multi-operation processing using two-phase locking and the multi-operation processing using timestamps are proposed. 
     &lt;Multi-Operation Processing Using Two-Phase Locking&gt; 
     Multi-operation processing using two-phase locking is a method that added two-phase locking technique to multi-operation processing providing concurrency control of transactions for locking data items which are processed by synthetic transactions. 
     In this method, lock operations are divided into two phases: a growing phase of only acquiring new locks on data items; and a shrinking phase of only releasing existing locks. Thus, a lock cannot be acquired once a lock is released. 
     In acquiring locks, shared locks are used for data items to be retrieved only, and exclusive locks are used for data items to be updated. 
     In order to avoid any data inconsistency to occur between multiple synthetic transactions, each synthetic transaction needs to be executed with multi-operation processing using two-phase locking. 
     The difference of multi-operation processing using two-phase locking from the conventional two-phase locking protocol is that locks are acquired by multiple synthetic transactions, which perform the multi-operation processing, instead of the conventional multiple transactions. Moreover, each synthetic transaction does not commit by itself, but each transaction contained in the synthetic transaction is committed consecutively. 
     Furthermore, the approach of dealing with a deadlock caused by multiple synthetic transactions is different from the conventional approach of dealing with a deadlock. If a deadlock is caused by multiple synthetic transactions, one of the synthetic transactions causing the deadlock is aborted by aborting the synthetic transaction having the lowest number of committed transactions. 
     In order to abort the synthetic transaction, the already committed transactions contained in the synthetic transaction are kept intact and only the uncommitted transactions contained in the synthetic transaction are aborted, rolled back, and resubmitted to the transaction processing system ( 100 ). 
     &lt;Example of Multi-Operation Processing Using Two-Phase Locking&gt; 
     In  FIG. 5-1  and  FIG. 5-2 , two synthetic transactions T G1,G2  and T G3,G4,G5  are concurrently executed through multi-operation processing using two-phase locking. 
     T G1,G2  is a synthetic transaction to perform its operation for the two relations DEPARTMENT ( 300 ) and EMPLOYEE ( 400 ), which is used as an example in Section 1.2. 
     T G3,G4,G5  is a synthetic transaction to perform its operation for the three relations PROJECT, EMPLOYEE, and DEPARTMENT, which is created from new transactions T 9 , T 10  and T 11  submitted to the transaction processing system ( 100 ) of  FIG. 1 . 
     In  FIG. 5-1  and  FIG. 5.2 , an operation of acquiring a shared lock on record r is expressed as read_lock(r), an operation of acquiring an exclusive lock on record r is expressed as write_lock(r), and an operation of releasing a lock from record r is expressed as unlock(r). Also a record in the relation DEPARTMENT ( 300 ) is expressed as D.ri, a record in the relation EMPLOYEE ( 400 ) is expressed as E.ri, and a record in the relation PROJECT (omitted from the diagram) is expressed as P.ri. 
     In  FIG. 5-1  and  FIG. 5.2 , synthetic transaction T G1,G2  locks the records in the order of D.r 6 , D.r 7 , D.r 8 , D.r 9 , D.r 19 , D.r 14 , D.r 3 , D.r 22 , D.r 23 , E.r 6 , E.r 14 , E.r 10  over time. Once all of the locks are acquired, the locks are released in the order starting from the record which has finished processing using multi-operation processing. 
     Similarly, synthetic transaction T G3,G4,G5  locks the records in the order of P.r 9 , P.r 18 , E.r 11 , E.r 21 , D.r 13 , D.r 14 , D.r 15 , D.r 19  over time. Once all of the locks are acquired, the locks are released in the order from the record which has finished processing using multi-operation processing. 
     The transactions contained in synthetic transactions T G1,G2  and T G3,G4,G5  are committed in the order of T 2 , T 9 , T 3 , T 11 , T 10 , T 7 , T 1 , T 5 , T 8 , T 4 , T 6 . 
     In multi-operation processing using two-phase locking, a deadlock may occur depending on locking order. For example, in  FIG. 6 , synthetic transaction T G1,G2  tries to lock record D.r 14  and synthetic transaction T G3,G4,G5  tries to lock record D. 19 ; however, they have already locked the records required by each other, thus causing a deadlock. 
     In order to remove the deadlock, either synthetic transaction T G1,G2  or synthetic transaction T G3,G4,G5  needs to be aborted. Since synthetic transaction T G1,G2  has one committed transaction T 2  and synthetic transaction T G3,G4,G5  has two committed transactions T 11  and T 9 , synthetic transaction T G1,G2  having fewer number of committed transactions is aborted. 
     In order to abort synthetic transaction T G1,G2 , the already committed transaction T 2  is left intact and only the uncommitted transactions T 7 , T 3 , T 1 , T 5 , T 8 , T 4  and T 6  are aborted, rolled back, and resubmitted to the transaction processing system( 100 ). 
     By executing each synthetic transaction through multi-operation processing using two-phase locking in this manner, the same data items are not updated simultaneously by multiple synthetic transactions so that data inconsistency does not occur. 
     &lt;Multi-Operation Processing Using Timestamps&gt; 
     For executing multiple synthetic transactions, multi-operation processing using timestamps assigns a timestamp to each synthetic transaction and executes the multiple synthetic transactions in the order from the synthetic transaction with smaller timestamp. 
     The differences of multi-operation processing using timestamps from the conventional timestamp protocol are: a timestamp is assigned to each synthetic transaction instead of each transaction; and a timestamp is assigned to each data item processed by synthetic transactions instead of assigning a timestamp to each data item processed by transactions. 
     Furthermore, when a data inconsistency has occurred between multiple synthetic transactions, the synthetic transaction causing the data inconsistency is aborted. 
     In order to abort a synthetic transaction, the already committed transactions contained in the synthetic transaction are left intact and only the uncommitted transactions contained in the synthetic transaction are aborted, rolled back, and resubmitted to the transaction processing system. 
     &lt;Steps of Multi-Operation Processing Using Timestamps&gt; 
     Multi-operation processing using timestamps assigns a read timestamp read_TS(X) and a write timestamp write_TS(X) to data item X which is processed by multiple synthetic transactions. 
     The read_TS(X) is the largest timestamp among all of the synthetic transactions that have successfully read data item X. 
     The write_TS(X) is the largest timestamp among all of the synthetic transactions that have successfully written data item X. 
     A timestamp for the synthetic transaction T G1, G2, . . . , Gn  is expressed as TS(T G1, G2, . . . , Gn ), which is obtained by assigning a timestamp (arrival time) to each transaction contained in the synthetic transaction and selecting the largest timestamp among all of the transactions that received respective timestamps. 
     When the synthetic transaction T G1, G2, . . . , Gn  performs a read operation read_item(X) or a write operation write_item(X) on data item X, the following rules shall be used to execute T G1, G2, . . . , Gn . 
     Case 1: Write Operation on Data Item X: 
     Synthetic transaction T G1, G2, . . . , Gn  requesting a write operation write_item(X) for data item X 
     (a) If read_TS(X)&gt;TS(TG 1 , G 2 , . . . , Gn) or write_TS(X)&gt;TS(T G1, G2, . . . , Gn ), abort synthetic transaction T G1, G2, . . . , Gn  by aborting all of the uncommitted transactions contained in T G1, G2, . . . , Gn . The aborted transactions are rolled back and resubmitted to the transaction processing system. 
     (b) If the condition of part (a) is not satisfied, execute write_item(X) of synthetic transaction T G1, G2, . . . , Gn  and set the value of write_TS(X) to TS(T G1, G2, . . . , Gn ). 
     Case 2: Read Operation on Data Item X: 
     Synthetic transaction T G1, G2, . . . , Gn  requesting a read operation read_item(X) for data item X 
     (a) If write_TS(X)&gt;TS(T G1, G2, . . . , Gn ), abort synthetic transaction T G1, G2, . . . , Gn  by aborting all of the uncommitted transactions contained in T G1, G2, . . . , Gn . The aborted transactions are rolled back and resubmitted to the transaction processing system. 
     (b) If write_TS(X)≦TS(T G1, G2, . . . , Gn ), execute read_item(X) of T G1, G2, . . . , Gn , and set the value of read_TS(X) to TS(T G1, G2, . . . , Gn ) if the value of TS(T G1, G2, . . . , Gn ) is larger than read_TS(X). 
     Next, based on these rules, concurrent execution of synthetic transactions T G1,G2  and T G3,G4,G5  is described by using multi-operation processing using timestamps. 
     &lt;Example of Multi-Operation Processing Using Timestamps&gt; 
       FIG. 7  shows the concurrent execution of synthetic transactions T G1,G2  and T G3,G4,G5  by using multi-operation processing using timestamps. 
     For updating record D.r 19 , synthetic transaction T G3,G4,G5  reads record D.r 19  (S 705 ) after which is read by synthetic transaction T G1,G2 (S 703 ); however, synthetic transaction T G3,G4,G5  writes record D.r 19  (S 707 ) before synthetic transaction T G1,G2  writes it. Therefore, if synthetic transaction T G1,G2  subsequently writes record D.r 19  (S 709 ), the value of record D.r 19  written by synthetic transaction T G3,G4,G5  is overwritten, causing synthetic transaction T G1,G2  to be aborted. How to find this data inconsistency by using multi-operation processing using timestamps is described as follows. 
     The timestamp of synthetic transaction T G1,G2  is set to 8 (assuming that the largest timestamp among all of the transactions contained in synthetic transaction T G1,G2  is the timestamp  8  of transaction T 8 ) (S 701 ). 
     Also, the timestamp of synthetic transaction T G3,G4,G5  is set to 11 (assuming that the largest timestamp among all of the transactions contained in synthetic transaction T G3,G4,G5  is the timestamp  11  of transaction T 11 ) (S 702 ). 
     First, when synthetic transaction T G1,G2  reads record D.r 19 , the value of write_TS(D.r 19 ) is 0 (initial value) so that the condition write_TS(D.r 19 )≦TS(T G1,G2 ) of case 2(b) is satisfied. Therefore, read_item(D.r 19 ) is executed (S 703 ) and the value of read_TS(D.r 19 ) is set to 8 (S 704 ). 
     Next, when synthetic transaction T G3,G4,G5  reads record D.r 19  (S 705 ), the value of write_TS(D.r 19 ) is 0 (initial value) and the value of TS(T G3,G4,G5 ) is 11 so that the condition write_TS(D.r 19 )≦TS(T G3,G4,G5 ) of case 2(b) is satisfied. Therefore, read_item(D.r 19 ) is executed (S 705 ) and the value of read_TS(D.r 19 ) is changed to 11 from 8 (S 706 ). 
     Next, when synthetic transaction T G3,G4,G5  requests a write operation write_item(D.r 19 ) for record D.r 19  (S 707 ), whether the condition read_TS(D.r 19 )&gt;TS(T G3,G4,G5 ) or the condition write_TS(D.r 19 )&gt;TS(T G3,G4,G5 ) of case 1(a) is satisfied is checked. Since the value of read_TS(D.r 19 ) is 11, the value of write_TS(D.r 19 ) is  0 , and the value of TS(T G3,G4,G5 ) is 11, the condition of case 1(a) is not satisfied. Therefore, write_item(D.r 19 ) of case 1(b) is executed (S 707 ) and the value of write_TS(D.r 19 ) is set to 11 (S 708 ). 
     Next, when synthetic transaction T G1,G2  requests a write operation write_item(D.r 19 ) for data item D.r 19  (S 709 ), whether the condition read_TS(D.r 19 )&gt;TS(T G1,G2 ) or the condition write_TS(D.r 19 )&gt;TS(T G1,G2 ) of case 1(a) is satisfied is checked. Since the value of read_TS(D.r 19 ) is 11, the value of write_TS(D.r 19 ) is 11, and the value of TS(T G1,G2 ) is 8, the condition of case 1(a) is satisfied. As a result, synthetic transaction T G1,G2  is aborted. 
     To abort the synthetic transaction T G1,G2 , the already committed transaction T 2  contained in synthetic transaction T G1,G2  is left intact and only the uncommitted transactions T 7 , T 3 , T 1 , T 5 , T 8 , T 4  and T 6  are aborted, rolled back, and resubmitted to the transaction processing system. 
     In this manner, multiple synthetic transactions are executed by using multi-operation processing using timestamps. 
     3. Transaction Processing Having Complex and Advanced Queries 
     How to process multiple transactions having complex and advanced queries such as queries containing join operations is described using a specific example. 
     The following three transactions T 12 , T 13  and T 14  performing their operations for the relation DEPARTMENT ( 300 ) of  FIG. 3-1  and the relation EMPLOYEE ( 400 ) of  FIG. 3-2  are submitted to the transaction processing system. 
     (T 12 ):BEGIN WORK; 
     Update Operation 1 of T 12    
     UPDATE DEPARTMENT 
     SET BUDGET=BUDGET+9000 
     WHERE DNUMBER=7; 
     Update Operation 2 of T 12    
     UPDATE EMPLOYEE 
     SET MGRSSN=470191111 
     WHERE SSN&gt;1876767888 AND SSN&lt;2111111124; 
     Query 1 of T 12    
     SELECT* 
     FROM DEPARTMENT, EMPLOYEE 
     WHERE DNUMBER=7 AND 
     SSN&gt;2111111124 AND SSN&lt;2411111133 AND 
     DNUMBER=DNUM; 
     COMMIT WORK; 
     (T 13 ):BEGIN WORK; 
     Update Operation 1 of T 13    
     UPDATE EMPLOYEE 
     SET DNUM=8 
     WHERE SSN=2311111132; 
     Query 1 of T 13    
     SELECT* 
     FROM DEPARTMENT, EMPLOYEE 
     WHERE DPHONE=‘23-3711’ AND 
     SSN&gt;2834567894 AND DNUM=DNUMBER; 
     Update Operation 2 of T 13    
     UPDATE DEPARTMENT 
     SET DNAME=‘SHIPPING’ 
     WHERE DNUMBER=7; 
     COMMIT WORK; 
     (T 14 ):BEGIN WORK; 
     Update Operation 1 of T 14    
     UPDATE EMPLOYEE 
     SET PHONE=‘23-5600’ 
     WHERE SSN=2311111132; 
     Update Operation 2 of T 14    
     UPDATE DEPARTMENT 
     SET BUDGET=BUDGET+4000 
     WHERE DNUMBER&gt;6 AND DNUMBER&lt;9; 
     COMMIT WORK; 
     For executing the submitted transactions, query trees need to be created for the queries containing join operations included in the transactions. Since transactions T 12  and T 13  each include queries containing join operations, the transaction processing system performs query optimization to create query trees (a), (b) shown in  FIG. 8  for these queries. A join operation in these query trees is expressed as a notation |X| and a select operation is expressed as σ. 
     Once the query trees are created, the transaction processing system obtains partial operations of the transactions T 12 , T 13  and T 14  and creates the following tasks. 
     (T 12 ): 
     (t 12   1 ):read_item(D.r 7 );
         D.r 7 .BUDGET:=D.r 7 .BUDGET+9000;   write_item(D.r 7 );       

     (t 12   2 ):read_item(E.r 9 );
         E.r 9 .MGRSSN:=470191111;   write_item(E.r 9 );   read_item(E.r 10 );   E.r 10 .MGRSSN:=470191111;   write_item(E.r 10 );       

     (t 12   3 ):read_item(D.r 7 ); 
     (t 12   4 ):read_item(E.r 12 );
         read_item(E.r 13 );       

     (t 12   5 ):TEMP_T 12 _ 3 |X| DNUMBER=DNUM  TEMP_T 12 _ 4 ; 
     (T 13 ): 
     (t 13   1 ):read_item(E.r 13 );
         E.r 13 .DNUM=8;   write_item(E.r 13 );       

     (t 13   2 ):read_item(D.r 6 ); 
     (t 13   3 ):read_item(E.r 19 );
         read_item(E.r 20 );       

     (t 13   4 ):TEMP_T 13 _ 2 |X| DNUMBER=DNUM  TEMP_T 13 _ 3 ; 
     (t 13   5 ):read_item(D.r 7 );
         D.r 7 .DNAME:=‘SHIPPING’;   write_item(D.r 7 );
 
(T 14 ):
       

     (t 14   1 ):read_item(E.r 13 );
         E.r 13 .PHONE:=‘23-5600’;   write_item(E.r 13 );       

     (t 14   2 ):read_item(D.r 7 );
         D.r 7 .BUDGET:=D.r 7 .BUDGET+4000;   write_item(D.r 7 );   read_item(D.r 8 );   D.r 8 .BUDGET:=D.r 8 .BUDGET+4000;   write_item(D.r 8 );       

     Tasks t 12   3  shown above is a selection operation σ DNUMBER=7 DEPARTMENT within the query tree of  FIG. 8(   a ). 
     Task t 12   4  shown above is a selection operation σ SSN&gt;2111111124 AND SSN&lt;2411111133  EMPLOYEE within the query tree of  FIG. 8(   a ). 
     Task t 13   2  shown above is a select operation σ DPHONE=‘23-3711’  DEPARTMENT within the query tree of  FIG. 8(   b ). 
     Task t 13   3  shown above is a select operation σ SSN&gt;2834567894  EMPLOYEE within the query tree of  FIG. 8(   b ). 
     Task t 12   5  shown above is a partial operation of transaction T 12  which is expressed as a join operation 
     TEMP_T 12 _ 3 |X| DNUMBER=DNUM  TEMP_T 12 _ 4  in the query tree of  FIG. 8(   a ). 
     TEMP_T 12 _ 3  is a temporary relation to be created when the selection operation of task t 12   3  is executed. 
     TEMP_T 12 _ 4  is a temporary relation to be created when the selection operation of task t 12   4  is executed. 
     The join operation of task t 12   5  is executed when the temporary relations TEMP_T 12 _ 3  and TEMP_T 12 _ 4  are created. 
     Task t 13   4  shown above is a partial operation of transaction T 13 , which is expressed as a join operation TEMP_T 13 _ 2 |X| DNUMBER=DNUM  TEMP_T 13 _ 3  in the query tree of  FIG. 8(   b ). 
     TEMP_T 13 _ 2  is a temporary relation to be created when the selection operation of task t 13   2  is executed. 
     TEMP_T 13 _ 3  is a temporary relation to be created when the selection operation of task t 13   3  is executed. 
     The join operation of task t 13   4  is executed when the temporary relations TEMP_T 13 _ 2  and TEMP_T 13 _ 3  are created. 
     Once the partial operations of the transactions are created, a transaction execution order is determined. In order to determine the transaction execution order, the processing cost of each transaction is obtained based on the partial operations contained in the transaction, and the transactions are sorted in the order from the transaction of smaller processing cost. 
     When the processing cost of transaction T 12  is 6, the processing cost of transaction T 13  is 5, and the processing cost of transaction T 14  is 2, the transaction execution order may be determined as T 14 , T 13 , T 12 . 
     Once the transaction execution order is determined, a precedence graph of  FIG. 8(   c ) indicating to update data in the transaction execution order is created. 
     Since transactions T 13  and T 12  perform their operations on the same records D.r 7  and E.r 13 , an edge is drawn from vertex T 13  to vertex T 12  according to the transaction execution order. 
     Since transactions T 14  and T 13  perform their operations on the same records D.r 7  and E.r 13 , an edge is drawn from vertex T 14  to vertex T 13  according to the transaction execution order. 
     Since transactions T 14  and T 12  perform their operations on the same record E.r 13 , an edge is drawn from vertex T 14  to vertex T 12  according to the transaction execution order. 
     Once the precedence graph is created, the partial operations contained in the transactions T 14 , T 13  and T 12  are retrieved as tasks and divided into groups for each database relation in the transaction execution order, resulting in the following. 
     
       
         
           
               
               
               
             
               
                   
               
             
            
               
                   
                 DEPARTMENT: 
                 Group G6 = {t 14   2 , t 13   2 , t 13   5 , t 12   1 , t 12   3 } 
               
               
                   
                 EMPLOYEE: 
                 Group G7 = {t 14   1 , t 13   1 , t 13   3 , t 12   2 , t 12   4 } 
               
               
                   
                 TEMP_T13_3: 
                 Group G8 = {t 13   4 } 
               
               
                   
                 TEMP_T12_4: 
                 Group G9 = {t 12   5 } 
               
               
                   
               
            
           
         
       
     
     To group the tasks of join operation, the temporary relation to be used as a retrieve source in the join operation is treated as a relation for grouping. Thus, task t 13   4  using the temporary relation TEMP_T 13 _ 3  as a retrieve source in its join operation is collected into group G 8 , and task t 12   5  using the temporary relation TEMP_T 12 _ 4  as a retrieve source in its join operation is collected into group G 9 . 
     Once the tasks are grouped and groups G 6 , G 7 , G 8  and G 9  are created, synthetic transaction T G6,G7,G8,G9  is created using the groups G 6 , G 7 , G 8  and G 9 . Then, each group contained in the synthetic transaction T G6,G7,G8,G9  is executed using multi-operation processing described in Section 1. 
     For executing the groups, the join operation of task t 13   4  in group G 8  is executed after finishing the execution of the select operation of tasks t 13   2  in group G 6  and the select operation of task t 13   3  in group G 7 . 
     Similarly, the join operation of task t 12   5  in group G 9  is executed after finishing the executions of the select operation of tasks t 12   3  in group G 6  and the select operation of task t 12   4  in group G 7 . 
     First, when the executions of groups G 6  and G 7  are completed, the execution of all of the tasks in transaction T 14  is finished; therefore, transaction T 14  is ended and committed. 
     Once transaction T 14  is committed, vertex T 14  and all of the outgoing edges from vertex T 14  are removed from the precedence graph of  FIG. 8(   c ). The result of this operation is shown in the precedence graph of  FIG. 8(   d ). 
     Next, once the execution of the join operation of task t 13   4  in group G 8  is finished, the execution of all of the tasks in transaction T 13  is finished; therefore, transaction T 13  is ended and committed. 
     Once transaction T 13  is committed, vertex T 13  and all of the outgoing edges from the vertex are removed from the precedence graph of  FIG. 8(   d ). The result of this operation is shown in the precedence graph of  FIG. 8(   e ). 
     Lastly, once the execution of the join operation of task t 12   5  in group G 9  is finished, the execution of all of the tasks in transaction T 12  is finished; therefore, transaction T 12  is ended and committed. As a result, the execution of synthetic transaction T G6,G7,G8,G9  is completed; therefore, all of the submitted transactions T 12 , T 13  and T 14  were executed and committed. 
     As described above, multi-operation processing providing concurrency control of transactions according to the present invention is able to handle transactions having complex and advanced queries. 
     4. Experiment Results 
     In this section, an experiment evaluating the transaction processing of multi-operation processing providing concurrency control of transactions and results thereof have been examined. In this experiment, the transaction processing time of the multi-operation processing providing concurrency control of transactions according to the present invention described in Section 1 and the transaction processing time of the conventional two-phase locking protocol that executes each transaction separately were measured, and then processing time of these methods were compared. 
     According to the steps described in Section 1.1, the multi-operation processing providing concurrency control of transactions executes each synthetic transaction serially by creating a synthetic transaction for multiple transactions submitted to the transaction processing system, executing the synthetic transaction, creating another synthetic transaction using the same procedure if a large number of new transactions is submitted once the execution of a single synthetic transaction is finished, and executing that another synthetic transaction. 
     Moreover, the multiple groups contained in a synthetic transaction are executed concurrently using multiple processes of the operating system. 
     A personal computer (a Celeron CPU 1.73 GHz processor, 1 GB main memory, a 145 GB disk) running Windows XP professional (registered trademark) as a database server was used to conduct this experiment. Our originally designed database management system software MOP-DB was installed on the database server, a database consisting of 6 relations was created using this software, and indices such as primary index and secondary index were added to each relation. 
     The MOP-DB software was designed to be capable for performing both the transaction processing of the multi-operation processing providing concurrency control of transactions according to the present invention and the transaction processing of the conventional two-phase locking protocol. 
     Next, our original client program was created, a large number of transactions written in SQL were submitted to the database server from the client program, and the time until all of the transactions are executed and committed by the database server was measured to obtain the transaction processing time of each method. 
     &lt;Experiment 1: Number of Transactions and Processing Time&gt; 
     One million records were stored in each relation, thus a total of six million records were added to six relations. The processing time for each method is shown in the table of  FIG. 9(   a ) and the graph of  FIG. 9(   b ) when the number of transactions to be sent to the database server is varied from 1000 to 10000 transactions respectively. 
     Considering that transaction processing time of each transaction to become shorter is the same as transaction processing speed to become faster, the transaction processing speed of multi-operation processing providing concurrency control of transactions is observed in general to be faster than the transaction processing speed of the conventional two-phase locking protocol for executing the number of transactions from 1000 to 10000 transactions. 
     As shown in the table of  FIG. 9(   a ), the transaction processing speed of multi-operation processing providing concurrency control of transactions obtained the transaction processing speed which is 18.36 times faster on average than the conventional two-phase locking protocol for executing the number of transactions from 1000 to 5000 transactions, and 19.98 times faster on average than the conventional two-phase locking protocol for executing the number of transactions from 6000 to 10000 transactions. 
     The transaction processing speed of multi-operation processing providing concurrency control of transactions tends to improve as the number of transactions increases. 
     As shown in the graph of  FIG. 9(   b ), the transaction processing speed of the conventional two-phase locking protocol decreased as the number of transactions increased, because many transactions read the same data item many times repeatedly, performed their update operations on the same data item separately, and wrote their updated results in the database many times repeatedly. 
     On the other hand, the transaction processing speed of multi-operation processing providing concurrency control of transactions improved as the number of transactions to be executed concurrently increased, because the same data item to be processed by multiple transactions is read only once, the update operations of the multiple transactions are executed consecutively on the same data item in the main memory, and only the last updated result is written in the database once. 
     &lt;Experiment 2: Database Size and Processing Time&gt; 
     The table of  FIG. 10(   a ) and the graph of  FIG. 10(   b ) show the processing time of requesting  10000  transactions for the database of different size having the number of records stored in 6 relations is varied from 0.6 million to 6 million records respectively. 
     As shown in the table of  FIG. 10(   a ) and the graph of  FIG. 10(   b ), multi-operation processing providing concurrency control of transactions obtained the transaction processing speed which is 8.04 times faster on average than the conventional two-phase locking protocol for the number of records from 0.6 million to 3 million records, and 15.59 times faster on average than the conventional two-phase locking protocol for the number of records from 3.6 million to 6 million records. Thus, the transaction processing speed tends to improve as the database size increases. 
     The conventional two-phase locking protocol took longer to execute each transaction as the database size increased. On the other hand, multi-operation processing providing concurrency control of transactions was able to execute each synthetic transaction efficiently without being affected by database size. 
     5. Conclusion 
     For processing multiple transactions submitted to the transaction processing system, multi-operation processing providing concurrency control of transactions has been proposed to solve the conventional problems caused by executing each transaction separately. 
     If a large number of transactions is submitted to the transaction processing system, this system of the present invention obtains partial operations of the submitted transactions, determines a transaction execution order, creates a precedence graph indicating to update data in the determined transaction execution order, retrieves the partial operations contained in the transactions as tasks, divides the retrieved tasks into groups for each database relation in the transaction execution order, creates a synthetic transaction using the groups created by grouping, and executes each group contained in the synthetic transaction using multi-operation processing. 
     The multi-operation processing determines an access order for blocks in the lined up order of the tasks in the group, reads a block in the determined access order, extracts the tasks accessing the read block from the group, and executes the task operations consecutively on a data item in the block in the lined up order of the tasks in the group. 
     Consecutive execution of the task operations on a data item in the block in the lined up order of the tasks in the group means to consecutively execute the task operations, which are partial operations of the transactions, on the data item according to the transaction execution order indicated in the precedence graph when the data item in the block exists in the precedence graph, that is, when the multiple tasks perform their update operations on the data item, the update operation of the first task is executed on the data item, the update operation of the next task is executed on the updated data item, such update operation is repeated in this manner, and only the last updated result is written in the database once after the update operation of the last task is executed. 
     By using this system to execute multiple submitted transactions, unlike the conventional transaction processing, retrieving the same data item many times repeatedly, executing an update operation on the retrieved data item separately, and writing the updated result in the database many times repeatedly are no longer required for each transaction. 
     The system of the present invention allows more efficient execution of a large number of transactions, because the data item to be processed by multiple transaction is retrieved only once, the update operations of the multiple transactions are executed consecutively on the retrieved data item in the main memory, and only the last updated result is written in the database once. 
     Since the present invention creates a precedence graph not containing any cycle for multiple submitted transactions, and for the data item to be processed by the multiple transactions, the update operations of the multiple transactions are executed consecutively on the data item according to the transaction execution order indicated in the precedence graph, these multiple submitted transactions are guaranteed to be executed in a serializable schedule. 
     Since each group contained in a synthetic transaction is executed for a different relation, even if the multiple groups contained in the synthetic transaction are executed concurrently, the same data item is not accessed simultaneously by the multiple groups. 
     Since the operations of the tasks collected into a group are executed consecutively on a data item in the block, which is read into the main memory, according to the transaction execution order indicated in the precedence graph, acquiring locks between multiple submitted transactions, making transactions wait, and aborting transactions are no longer required. 
     The present invention creates a single synthetic transaction for multiple submitted transactions and executes the synthetic transaction; once the single synthetic transaction is executed, if new multiple transactions are submitted, the present invention creates another synthetic transaction for these transactions and executes that synthetic transaction. Therefore, as long as synthetic transactions are executed serially, no locks are required. Moreover, deadlocks do not occur, and the multiple groups contained in a synthetic transaction are executed concurrently. 
     While the transaction processing speed may be improved significantly by executing synthetic transactions serially, the multi-operation processing using two-phase locking and the multi-operation processing using timestamps have been proposed to execute multiple synthetic transactions concurrently so as to efficiently utilize hardware resources such as CPU and disk.