Abstract:
A method for physically executing parallel operations in a resource manager ( 10 ) while retaining the effect of a defined logical serial ordering is provided. A plurality of operations is applied by a client application ( 16, 17, 18 ) to the resource manager ( 10 ). The method includes commencing a transaction between the client application ( 16, 17, 18 ) and the resource manager ( 10 ). The resource manager ( 10 ) receives a plurality of operations from the client application ( 16, 17, 18 ) in a logical order. The client application ( 16, 17, 18 ) indicates to the resource manager ( 100  that these operations can be applied in parallel. The resource manager ( 10 ) implements the operations in parallel and controls the parallel operations to ensure that the plurality of operations is executed such that the result of the parallel execution is the same as the result that would have been achieved by serial execution in the logical order. The transaction then ends.

Description:
FIELD OF INVENTION  
         [0001]    This invention relates to a method and apparatus for ordering parallel operations in a resource manager.  
         BACKGROUND OF THE INVENTION  
         [0002]    Resource managers include databases, messaging systems, and other forms of systems in which data is managed. Databases may include hierarchical or tree structure databases (for example, IMS®), network data structures, relational database systems (for example, DB2®, Oracle, Microsoft® SQL server, etc), object databases, and XML databases. Messaging systems may include messaging middleware (for example, MQSeries®). The term “resource manager” should be understood in a broad context including, but not limited to, all the above types of system. (IMS, DB2 and MQSeries are trademarks or IBM Corporation and Microsoft is a trademark of Microsoft Corporation).  
           [0003]    In resource managers such as database systems, certain applications implement a sequence of database reads and updates with a very high expectation that all will work correctly. An example of such an application is a programming applying replicated data to a replication target database.  
           [0004]    These applications frequently have to wait on database calls while the database reads information. This is always true for reading. It is often true for updating, as an update often includes only part of a row and the database implementation must read the full row before it can apply the update and rewrite the result.  
           [0005]    In order to speed up database processing time, applications can be written to be multithreaded to provide parallelism within the database access. This is referred to as application controlled parallelism. In this way the data is read in the beginning and more than one request is carried out at the same time. This can result in the problem that if several requests are carried out simultaneously the wrong answer may be reached if the requests conflict with each other.  
           [0006]    Writing applications in this way can be quite awkward, as the application is required to make an analysis of interdependencies in the update stream to prevent the processing of updates in an incorrect order.  
           [0007]    Known application controlled parallel systems which use analysis of requests carried out by the application external to the database have the following disadvantages. The logical analysis is very difficult. Simple updates may trigger other unforeseen effects and deletions may result in cascaded deletes. On a physical level, databases may lock to prevent a wrong answer being returned and such a lock may be too coarse. Examples of coarse physical locking are given later.  
           [0008]    The problem of read delays may also be partially handled by use of an asynchronous interface for SQL (Structured Query Language) calls. Structured Query Language is a database programming language that is only used to create queries to retrieve data from a database.  
           [0009]    In an asynchronous interface each call may have an additional parameter, which is a pointer to an associated control block for reporting status and return information. Return information is handled by existing parameters.  
           [0010]    Asynchronously requested results may be made available in one of three ways.  
           [0011]    1. Synchronously on return from the call. (For example, where the request is invalid.)  
           [0012]    2. On return from another call on the same database connection.  
           [0013]    3. Completely asynchronously, with some form of event posting or callback.  
           [0014]    Option (3) is more complicated to implement, requiring a more complicated interprocess communication (IPC) mechanism between the client (the application) and the server (the database). As the application will typically be issuing a stream of calls in any case, (2) will be adequate with no need to implement (3).  
           [0015]    Various interfaces already exist for such asynchronous calls. However, most are limited to one outstanding call per connection. This allows application/database parallelism, but not parallelism of database operations for a single connection.  
           [0016]    An example of an existing interface for asynchronous database calls is given at: http://support.microsoft.com/support/kb/articles/Q143/0/3 2.asp.  
         DISCLOSURE OF THE INVENTION  
         [0017]    It is an aim of the present invention to provide a method and apparatus that enable an interface for asynchronous operations, such as database calls or messages, that permit parallel operations on the same connection. It is a further aim to implement logical ordering of the operations based on a request order between calls implemented in parallel.  
           [0018]    According to a first aspect of the present invention there is provided a method for ordering physically parallel operations in a resource manager, in which a plurality of operations is applied by a client application to the resource manager, the method comprising: commencing a transaction between the client application and the resource manager; the resource manager receiving a plurality of operations from the client application in a logical order; the client application indicating to the resource manager that these operations can be applied in parallel; the resource manager implementing the operations in parallel; the resource manager controlling the parallel operations to ensure that the plurality of operations is executed such that the result of the parallel execution is the same as the result that would have been achieved by serial execution in the logical order; and ending the transaction.  
           [0019]    The resource manager may be a database system and the operations are read, write and update requests. Alternatively, the resource manager may be a messaging system and the operations are messaging operations.  
           [0020]    In certain situations, the resource manager may complete a first operation before enabling a second operation to commence. On completion of a first operation holding a lock on a given resource, the resource manager may control an unlock of that resource that allows other operations in the same transaction and requiring a conflicting lock on that resource to commence.  
           [0021]    A conflict between operations may be a physical locking conflict or a logical conflict. Locks on any resource may hold information on both the transaction and the order of the operation within the logical sequence.  
           [0022]    Preferably, if a later operation in the logical order acquires a lock on a given resource before an earlier operation also attempts to acquire a conflicting lock on this resource, the resource manager detects a conflict.  
           [0023]    In a first embodiment where conflict is detected, the resource manager may (a) back out of the later operation but does not back out the earlier operation or other operations within the transaction, (b) grant the lock to the earlier operation, (c) allow the earlier operation to run, and (d) rerun the later operation. The earlier operation may be run to completion before the later operation is rerun or, alternatively, the later operation may be rerun as soon as the lock has been granted to the earlier operation.  
           [0024]    In a second embodiment where conflict is detected, the resource manager may back out all the work for all the operations in the transaction and rerun all the operations while ensuring that the conflicting operations are run in the correct logical order, wherein any reads may be read from the buffer of the resource manager.  
           [0025]    In a third embodiment where conflict is detected, the resource manager may back out of the transaction and report transaction failure to the client application; the client application may then elect to rerun the transaction or take alternative appropriate action.  
           [0026]    In any of the above embodiments where conflict is detected, if there are repeated conflicts, the resource manager may decrease the level of parallelism of operations.  
           [0027]    Execution of the initial read part of each parallel operation prior to its first update part may be executed in parallel but update requests are executed in the specified logical order. As much data as possible may be read by the resource manager for each operation with a transaction before the update parts of these operations are processed.  
           [0028]    An asynchronous interface may include a pointer for each operation to an associated control block for reporting status and return information. The results may be provided on return from another operation on the same server connection.  
           [0029]    Operation status may be reported to the client application using an asynchronous callback or signalling mechanism.  
           [0030]    The resource manager may be coordinated with other resource managers by a transaction coordinator. When a resource manager detects a conflict it may back itself out and recover by retry; but this is not reported to the coordinator, and no backout is executed of the overall transaction, or of the work already done by other coordinated resource managers.  
           [0031]    According to a second aspect of the present invention there is provided a resource manager in which a plurality of operations within a transaction is applied by a client application to the resource manager, the resource manager comprising: receiving means for receiving a plurality of operations from the client application in a logical order, the client application indicating to the resource manager that these operations can be applied in parallel; means for implementing the operations in parallel and means for controlling the parallel operations to ensure that the plurality of operations is executed such that the result of the parallel execution is the same as the result that would have been achieved by serial execution in the logical order.  
           [0032]    The resource manager may be a database system and the operations are read, write and update requests. Alternatively, the resource manager may be a messaging system and the operations are messaging operations.  
           [0033]    The resource manager may comprise means for, in certain situations, completing a first operation before enabling a second operation to commence.  
           [0034]    The resource manager may comprise means, responsive to completion of a first operation holding a lock on a given resource, for controlling an unlock of that resource that allows other operations in the same transaction and requiring a conflicting lock on that resource to commence.  
           [0035]    A conflict between operations can, for example, be a physical locking conflict or a logical conflict.  
           [0036]    In one embodiment, locks on any resource hold information on both the transaction and the order of the operation within the logical sequence.  
           [0037]    In one embodiment, the resource manager comprises means, responsive to a later operation in the logical order acquiring a lock on a given resource before an earlier operation also attempts to acquire a conflicting lock on this resource, for detecting a conflict.  
           [0038]    The resource manager may comprise means, responsive to detecting conflict, for (a) backing out of the later operation but not backing out the earlier operation or other operations within the transaction, (b) granting the lock to the earlier operation, (c) allowing the earlier operation to run, and (d) rerunning the later operation.  
           [0039]    The earlier operation may be run to completion before the later operation is rerun.  
           [0040]    The later operation may be rerun as soon as the lock has been granted to the earlier operation.  
           [0041]    In one embodiment, the resource manager comprises means, responsive to conflict being detected, for backing out all the work for all the operations in the transaction and rerunning all the operations while ensuring that the conflicting operations are run in the correct logical order, wherein any reads can be read from the buffer of the resource manager.  
           [0042]    In one embodiment, the resource manager comprises means, responsive to conflict being detected, for backing out of the transaction and reporting transaction failure to the client application; the client application may then elect to rerun the transaction or take alternative appropriate action.  
           [0043]    In one embodiment, the resource manager comprises means, responsive to repeated conflicts being detected, for decreasing the level of parallelism of operations.  
           [0044]    In one embodiment, execution of the initial read part of each parallel operation prior to its first update part is executed in parallel but update requests are executed in the specified logical order.  
           [0045]    In one embodiment, the resource manager comprises means for reading as much data as possible for each operation with a transaction before the update parts of these operations are processed.  
           [0046]    The resource manager may include an asynchronous interface with a pointer for each operation to an associated control block for reporting status and return information. The results of operations may be provided on return from another operation on the same server connection.  
           [0047]    An asynchronous call back or signalling mechanism may be provided which reports operation status to the client application.  
           [0048]    A transaction coordinator may be provided for coordinating the resource manager with other resource managers.  
           [0049]    According to a third aspect of the present invention there is provided a computer program product stored on a computer readable storage medium for ordering physically parallel operations instructed by a client application, comprising computer readable program code means for performing the step of: controlling operations, in a transaction entered into between the client application and a resource manager, said plurality of operations being implemented by the resource manager in parallel, the operations being executed to ensure that the plurality of operations is executed such that the result of the parallel execution is the same as the result that would have been achieved by serial execution in the logical order.  
       
    
    
     BRIEF DESCRIPTION OF THE DRAWING  
       [0050]    An embodiment of the invention is now described, by way of example only, with reference to the accompanying drawing in which:  
         [0051]    [0051]FIG. 1 is a schematic diagram of a database system in which the method and system of the present invention could be applied. 
     
    
     DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0052]    A database is described as an example of a resource manager although, as stated above, other non-database resource managers may also use the method and system of the present invention.  
         [0053]    Referring to FIG. 1, a database  10  is shown which has a datastore  11  in which the data held in the database is stored. The database  10  includes a database controller  12 , a query processor  13  and a buffer  14 . The controller  12  includes a locking control  15  for locking areas of the datastore  11  and areas of the buffer  14  during accesses. Applications  16 ,  17 ,  18  which wish to access data in the database  10  make queries via the query processor  13 .  
         [0054]    In conventional systems, an application  16 ,  17 ,  18  accesses data in the database  10  by issuing an operation. An operation is implemented by the database  10  using the following simplified flow:  
         [0055]    accept command  
         [0056]    read data into buffers  
         [0057]    lock  
         [0058]    update buffers  
         [0059]    return to caller  
         [0060]    lazy write buffers (to log and to table store)  
         [0061]    on prepare, force log  
         [0062]    In the described method, a database operation has a different flow which can be shown as follows:  
         [0063]    accept command  
         [0064]    return to caller  
         [0065]    read data into buffers  
         [0066]    lock  
         [0067]    update buffers  
         [0068]    report asynchronously to caller  
         [0069]    lazy write buffers (to log and to table store)  
         [0070]    on prepare, force log  
         [0071]    The above flow is the simple case, for more complex queries there may be more iteration over the read data into buffers, lock and update buffers especially if an update triggers other updates or in the case of cascaded deletes etc.  
         [0072]    Databases and other resource managers typically implement the concept of transaction. This traditionally covers four areas (so called ACID properties), Atomicity, Consistency, Isolation and Durability (see for example http://www.cbbrowne.com/info/tpmonitor.html). The most important feature in this case is atomicity. The application marks the beginning and end of a transaction using special calls. The resource manager then ensures that either (a) all the operations carried out by the application during this transaction are applied, or (b) none of the operations applied during this transaction are applied.  
         [0073]    During the life of a transaction, the application may request the resource manager to abort the transaction, in which case the operations applied so far are ‘backed out’ as if they never happened. Also, the resource manager may inform the application that it is impossible to complete the transaction, for example because of deadlock or some failure situation. Again, the operations applied so far are backed out. It is up to the application to reapply the operations of the transaction, or some suitable variant thereof, if deemed appropriate.  
         [0074]    A transaction may involve a single database or other resource manager source, known as single phase. It may have more than one source, known as coordinated or two phase; this requires a transaction coordinator in addition to the coordinated set of resource mangers. This invention operates in either of these situations.  
         [0075]    The described method takes advantage of the application defined transaction boundaries, and uses them as asynchrony boundaries to control the parallelism. This is natural for the application programmer used to transactions. Also, the normal transactional controls implemented by the resource manager (and transaction coordinator if applicable) are used with the modifications described below. These modifications are mainly involved with the extra Consistency issues of assuring logical ordering while implementing physical parallelism. The implementation of other Atomicity, Consistency, Isolation and Durability properties carries through unchanged.  
         [0076]    Each transaction on the database has an identification (ID). In the described method the notation xid is used for an identification of a transaction.  
         [0077]    If a transaction wants to read data from a database, the transaction applies a read lock to the relevant data in the database. A read lock prevents any other transactions from updating the data until the transaction with the lock has finished. More than one transaction can read the same data simultaneously and each transaction applies its own read lock.  
         [0078]    If a transaction wants to write data to a database, the transaction applies a write lock to the relevant data. A write lock prevents any other transaction from reading or writing to the locked data until the lock is removed by the locking transaction.  
         [0079]    Each lock is owned by a transaction. When the transaction completes, the lock is released. If a conflict arises between transactions due to locks, there are known methods in the prior art for resolving such conflicts.  
         [0080]    In the described method, an application sends a sequence of operations in a single transaction. Each operation is assigned a sequence number within the transaction identification, so that each operation is labeled as to its sequence within a transaction. This helps control internal parallelism in the database.  
         [0081]    In the described example, an operation has an identifier of xid/seq#—which means that the operation has sequence number # in transaction x.  
         [0082]    If another transaction has a lock on data which needs to be accessed by an operation, then existing methods of dealing with conflicts between locks of transactions are used.  
         [0083]    However, if an operation of a different sequence number but the same transaction has a lock on the data, the following described method is used to resolve the conflict.  
         [0084]    The following options work on the assumption that for the majority of accesses conflict will not occur. If a conflict occurs, the database backs out and reruns the operations in the correct order. This form of parallelism in which operations run in parallel until a conflict arises, then the conflict is dealt with only at that time, results in a more time efficient method than both serial and application controlled parallel methods.  
         [0085]    Option 1:  
         [0086]    In option 1, locking is extended using each operation xid/seq# as an ‘owner’ of a lock where there may be more than one parallel operation in a transaction.  
         [0087]    Interactions between different transactions, xid1 and xid2, are handled as known from conventional systems.  
         [0088]    The following are options of actions to take when xid/seqx already holds lock and xid/seqy requests lock.  
         [0089]    1a. If y&lt;x there is a problem as seqy should have been carried out before seqx. The choice is as follows:  
         [0090]    1a1. Back out database work for seqx, let y run, and rerun x.  
         [0091]    This requires much more new work in database implementation. So it would be beneficial to keep track of the information to be able to do a partial back out for seqx.  
         [0092]    1a2. Back out all database work, and rerun automatically within the database, making sure seqy is completed before seqx starts.  
         [0093]    This is probably the preferred option. Everything in the transaction is wound back. Databases are always set up to be able to do this and therefore the method invokes existing database code. The back out is not too expensive, as most of required reading will now be in buffers. The database does not need to go back to the application, the database can just rerun the backed up data.  
         [0094]    The rerun makes sure that the operations are in the correct sequence.  
         [0095]    Parallelism has the aim of avoiding waiting for reading into buffers to complete. The reading to the buffers in this option has already been done before the need to back out. Therefore, the time expensive work has already been done and the backing out is not too time expensive.  
         [0096]    1a3. Back out the complete transaction and warn application, it is then the application&#39;s responsibility to rerun the transaction.  
         [0097]    This option may be simpler to implement, but slower and more work for the application. The database tells the application that it has got the sequence order wrong and that the application needs to re-instruct. This uses the conventional processing of a deadlock in which two applications try to do conflicting things and one must back out.  
         [0098]    1ax. This is an extension to any 1a option, where repeated conflicts are found. This option automatically decreases parallelism in future.  
         [0099]    This option can be used if back outs are being detected too often and time is being wasted. The system automatically reduces the degree of parallelism that the database attempts.  
         [0100]    The proportion of time spent in options 1a is very low which means the overall system benefits from the parallelism of the cases in which conflict does not arise.  
         [0101]    1b. If y&gt;x. If the sequence is correct, the database must make sure that the first operation finishes its work before the second operation starts. This is the same effect as running sequentially. In this case there is a choice:  
         [0102]    1b1. Wait until x completes before letting y continue.  
         [0103]    Typically a database holds a lock until the end of the transaction, but this cannot be done in this case as there are other operations in the transaction. If the lock held by x and x is completely finished, then the database knows it can safely run y. The code running x in the database does not need to be changed.  
         [0104]    1b2. Have x do ‘unlock local’ [change lock owner from xid/seqx to xid/0] when x has finished with the lock.  
         [0105]    As soon as x knows its finished with a particular resource, it releases lock locally so that operations in the same transaction can start. This option requires changes in the database to effect the local unlock but more parallelism is obtained.  
         [0106]    Option 2:  
         [0107]    2. Parallelise read, but not update. This is an option that is cheaper to implement than Option 1 but is less beneficial.  
         [0108]    2a. Only parallelise reads prior to the first write.  
         [0109]    Reads are the main time consumers in database operations so a lot of time can be saved by parallelising the reads only. The database will not allow any operation to move onto the next processing steps until the previous operation is complete. In other words, the reads are carried out in parallel, but the remainder of the components of an operation are carried out serially. This may result in iterations in the remaining components of operations which have a conflict.  
         [0110]    2b. Change internals to read as much as possible before any update.  
         [0111]    This option guesses that data is not going to be updated and reads it in advance. When the operations are carried out in parallel, a double check is made as to whether the read was right. In other words, this requires a double check before using preread data, and some reread. (For example using the embodiment given below, move Dot to Sales, deductDotSalary, the wrong department may have been preread for deductDotSalary.)  
         [0112]    This option involves more work to implement but has performance benefits over 2a.  
         [0113]    Embodiments of the described options are given using an example of a simple database shown in Tables 1 and 2 of employee&#39;s salaries and departments.  
                                 TABLE 1                           Employees                Employee   Department   Salary                       Sally   Sales   100,000            Sam   Sales   80,000           Dick   Development   90,000           Dot   Development   90,000                      
 
         [0114]    [0114]                             TABLE 2                           Departments                Department   Balance                       Development   2,000,000           Sales   2,000,000                        
         [0115]    The following are examples of update queries which may be instructed.  
         [0116]    U1: move Dot to sales;  
         [0117]    U2: change Dot&#39;s salary to 95,000;  
         [0118]    U3: increase Dot&#39;s salary by 5%;  
         [0119]    U4: deduct Dot&#39;s salary from department balance;  
         [0120]    U5: change Sam&#39;s salary to 85,000.  
         [0121]    U6: increase Dot and Sam&#39;s salary by 5%  
         [0122]    It will be readily noted that some of the above update queries conflict with each other and some are completely independent. For example:  
         [0123]    U2 and U5 do not conflict. Logically U2 and U5 can be carried out in parallel. This is the case also at the physical level if row locking is used. However, if page locking is used, it is possible that a lock of information on a page for U2 will cause a conflict and force U5 to back out and to try again. This needs to be avoided for optimization of the process.  
         [0124]    U1 and U2 are logically independent. They will be independent at the physical level if field locking is used. However, they will conflict at the physical level even with row locking: they cannot be done in parallel as the same row for Dot is needed for both updates.  
         [0125]    U2 and U3 are dependent on each other and this would be noticed logically from outside the database system.  
         [0126]    In the case of U1 and U4 it is difficult to resolve the conflict as the two updates are order dependent. If U1 is carried out first and Dot is moved to Sales, then U4 results in an update of the Sales department balance. If U4 is carried out first, the Development department balance will be changed before Dot is moved.  
         [0127]    As seen from the above examples, conflict between operations is not easy to predict and therefore an application controlled parallel system may make erroneous predictions. In the described method, conflicts in parallel operations are handled by the database as they occur as detailed in the options above. Code using the described method will run inside the database and automatically respond to the actual physical locking of the database.  
         [0128]    In the following diagrams, examples are shown for the prior art and the options of the described method detailed above. Prior art shown in these diagrams is ‘simple’, non-parallel prior art. The prior art of application controlled parallelism is not shown, as this is very dependent on implementation details of said application  
         [0129]    The performance of the prior art of application controlled parallelism depends very much on how much knowledge the application has of database locking details, and can thus permit ‘suitable’ parallelism. The performance of application controlled parallelism will usually be close to that of the describe method, but:  
         [0130]    a) It will never be better than the described method and will not always be close, for example, when it guesses wrong about locking.  
         [0131]    b) The complex dependency analysis coding in the application in the prior art, at best, mimics the correctness achieved by the described method.  
         [0132]    c) If incomplete dependency analysis is used in the prior art, there is a risk of the wrong answer being generated.  
         [0133]    For simplicity, all the following diagrams assume row locking. As indicated in the examples above, there may be enhanced parallelism if field locking is used or worse parallelism if page locking is used, but the principle is not changed.  
         [0134]    The following notation is used in the examples:  
         [0135]    1 !—accept command  
         [0136]    2 R.Dot—read Dot&#39;s record into buffers (or page containing Dot&#39;s record)  
         [0137]    3 LR.Dot—read lock on Dot&#39;s row  
         [0138]    LW.Dot—write lock on Dot&#39;s row  
         [0139]    LU.Dot—‘local’ unlock of Dot&#39;s row (as in 1b2)  
         [0140]    4 U.Dot—update Dot&#39;s record in buffer  
         [0141]    5 W.Dot—start lazy write of Dot&#39;s record (or page containing Dot&#39;s record)  
         [0142]    6 *—complete transaction— 
         [0143]    --- indicates wait time for reading  
         [0144]    === indicates wait time for lock  
         [0145]    ??? indicates a thread that happens to get ‘behind’ 
         [0146]    # indicates recognition of ‘wrong order’ processing (case 1a).  
         [0147]    The above notation is given for “Dot”. It will be appreciated that similar notation applies to the other records, for example, R.Dick, W.sales, etc etc  
         [0148]    Each timing diagram is between the following lines:  
         [0149]    --------------------------------------  
         [0150]    --------------------------------------  
         [0151]    Each row of timing diagram is a separate command on the list. Time moves from left to right. The final row T of each diagram indicates transaction.  
       EXAMPLE 1  
       [0152]    No logical conflicts, no physical conflicts.  
         [0153]    This shows the general behaviour of serial prior art and options 1 and 2 in the simplest and commonest case.  
         [0154]    Command list: U2 (change Dot&#39;s salary to 95,000), U5 (change Sam&#39;s salary to 85,000).  
                                                           Ex1/PA: with prior art       SEE           Ex1/1: with parallelism, option 1    {close oversize parenthesis}    APPENDIX           Ex1/2: with parallelism, option 2       A                      
 
       EXAMPLE 2  
       [0155]    Physical conflict (due to row locking, even though no logical conflict).  
         [0156]    This shows the effect of conflict in the serial prior art, and options 1 and 2. In this case, the second command does NOT try to jump over the first command. (eg Option 1b).  
         [0157]    Command list: U1 (move Dot to sales), U2 (change Dot&#39;s salary to 95,000).  
                                                           Ex2/PA: with prior art       SEE           Ex2/1b1: with parallelism, option 1b1       APPENDIX           Ex2/1b2: with parallelism, option 1b2    {close oversize parenthesis}    B           Ex2/2: with parallelism, option 2                      
 
         [0158]    Note reduced waiting for R.Dot for U2 in all parallel cases as the buffer is already being fetched with parallelism.  
         [0159]    Ex2/PA is very similar to Ex1/PA, and Ex2/2 is very similar to Ex1/2. These cases were not attempting enough parallelism to be impacted by the conflict.  
         [0160]    Ex2/1b1 and Ex2/1b2 are still better than Ex2/PA and Ex2/2, but because of the conflict the improvement is not as marked as in Example 1.  
         [0161]    The benefits of 1b2 over 1b1 do not show up on this illustration, but see Example 5.  
       EXAMPLE 3  
       [0162]    Simple logical conflict.  
         [0163]    This example shows the effect of conflict in serial prior art, and options 1 and 2. In this case the second command does NOT try to jump over first command (eg, option 1b).  
         [0164]    Command list: U2 (change Dot&#39;s salary to 95), U3 (increase Dot&#39;s salary by 5%).  
         [0165]    The picture will look exactly the same as Example 2. It is not important at the implementation level that the conflict was logical as well as physical. Once there is a conflict, it must be resolved.  
         [0166]    It should be noted that unless there is a but in the database physical locking implementation, it is impossible to get a logical conflict with no physical conflict  
       EXAMPLE 4  
       [0167]    Simple logical conflict.  
         [0168]    This case shows the effect of conflict in 1a1, 1a2, 1a3, where second command DOES try to jump over first command (eg, option 1a).  
         [0169]    Because of the strict serial behaviour of the prior art, and stricter serial behaviour of option 2, there is no equivalent case.  
         [0170]    The comparable behaviour of prior art and option 2 is exactly as for Examples 2 and 3.  
         [0171]    Command list: U2 (change Dot&#39;s salary to 95,000), U3 (increase Dot&#39;s salary by 5%)  
                                                   Ex4/1a1: with parallelism, option 1a1 - SEE APPENDIX C                      
 
         [0172]    This is a simple but artificial case. Random thread switching lets U2 get behind U3.  
         [0173]    The problem is more likely to occur where the first command is more complex than the second, and has more initial R.xxx work to do. This is not illustrated as such illustration would be more complex and confusing and would not clarify the point any better.  
         [0174]    The sooner the U2 thread gets control after the ???, the sooner it will detect the problem #. In this example, U2 got control after U.Dot. Similar pictures are possible where:  
         [0175]    a) U3 gets the lock, but it is detected almost at once (before performing U.Dot). The lock must be taken from U3 and given to U2, but there is no significant undo to be performed on U3.  
         [0176]    b) U3 also initiates W.Dot before detection. W.Dot has to be undone as well as undoing U.Dot.  
                                                           Ex4/1a2: with parallelism, option 1a2       SEE                {close oversize parenthesis}            Ex4/1a3: with parallelism, option 1a3       APPENDIX D                      
 
         [0177]    The first transaction dies completely, and a second transaction takes over (with help from the application, which resubmits the command list).  
         [0178]    A similar scenario to all three cases above would apply even if there was no logical conflict, e.g. U1 (move Dot to sales), U2 (change Dot&#39;s salary to 95,000). Even though these could safely be applied in the ‘wrong’ order, the physical locking of the system is too course to recognize this. It will perform back out/retry processing as in Ex4/1a1, Ex4/1a2 and Ex4/1a3, even though this processing is not strictly necessary.  
       EXAMPLE 5  
       [0179]    Slightly more complex logical conflict.  
         [0180]    This case shows the effect of the difference of 1b1 and 1b2. These are sub-cases of 1b, where the second command does NOT try to jump over first command.  
         [0181]    Command list: U6 (increase Dot and Sam&#39;s salary by 5%), U2 (change Dot&#39;s salary to 95,000)  
                                                           Ex5/1b1: with parallelism, option 1b1       SEE                {close oversize parenthesis}            Ex5/1b2: with parallelism, option 1b2       APPENDIX E                      
 
         [0182]    The difference between 1b1 and 1b2 is clearer than in Example 2. In particular, U2 is completed much earlier If both U6 and U2 were more complicated but slightly conflicting, (eg U6 (update Dot and Sam), U7 (update Dot and Dick)) there would be much more parallelism in 1b2 than 1b1. This is not shown, because the illustrations (especially the 1b1 case) would be too wide.  
         [0183]    An example of an implementation of the described method in SQL code is given below.  
                                                                                                                                                                                                         // -----------------------------------------       // New options defined by sql header files:       // -----------------------------------------       typedef enum { SQL_RUNNING, SQL_COMPLETE_OK, SQL_FAILED }       sqlstatus;       typedef struct SSQLASYNCCB {                sqlint32 sqicode;   // sqlcode for final completion           sqlstatus asyncState;   // asynchronous state            }   SQLASYNCCB;            #define SQLASYNCCB_DEFAULT {0, SQL_UNSET}            SQLSYNCCB *SQL_FIRSTCOMPLETE;   //pointer to the first complete       operation           // (probably held as a member of sqlca)            // -----------------------------------------       // -----------------------------------------       // NEW EXEC SQL calls       // -----------------------------------------                EXEC SQL ASYNC (cb) sqlcall;   //this will perform sqlcall            asynchronously                EXEC SQL WAITALL (cb1, . . . );   //this will wait till all listed            operations complete                EXEC SQL WAITANY (cb1, . . . );   //this will wait until any            listed operations complete                EXEC SQL WAITANY;   //this will wait until any            outstanding operation on connection complete       // -----------------------------------------       Example:       void test () {                SQLASYNCCB   cb1=SQLASYNCCB_DEFAULT,                cb2=SQLASYNCCB_DEFAULT,           cb3=SQLASYNCCB_DEFAULT;                EXEC SQL ASYNC (cb1) UPDATE1 . . . ;           EXEC SQL ASYNC (cb2) UPDATE2 . . . ;           EXEC SQL ASYNC (cb3) UPDATE3 . . . ;           EXEC SQL WAITALL;           if (cb1.SQLCODE) . . . error handling           if (cb2.SQLCODE) . . . error handling           if (cb3.SQLCODE) . . . error handling           EXEC SQL COMMIT;            };                  
 
         [0184]    Extension:  
         [0185]    To save the client programming scanning for completed tasks, the server could produce information on each call about other, asynchronous call completed. For example, the number of such calls, a list of such calls, and a return code summary for such calls.  
                                                                                                                   Add                struct SSQLASUNCCB *pNextComplete;   // pointer to the next            complete to SQLASYNCCB;       #define SQLASYNCCB_DEFAULT {0, SQL_UNSET, NULL}       And include as statically available data from each call (eg in       sqlca)                sqlint32 SQL_ASYNCNUMCOMPLETE;   // number of async calls            completed during execution of last call                bool SQL_ASYNCOK;   // true if ALL async calls            completed were OK                SQLASYNCCB *SQL_ASYNCFIRSTCOMPLETE;   // pointer to control            block for the first complete async call                  
 
         [0186]    It will be clear to one skilled in the art that there are many other mechanisms to report back asynchronous completion to the application. For example, a specific interface may be provided for the application to poll, or a callback mechanism may be implemented. In many cases the application will not be interested in details, and will be content with the (normal) successful return of the transaction completion operation, with (occasional) error returns such as Rollback, In any case, the details by which the status of parallel operations is reported back to the application will not significantly impact the implementation detail of the parallel operation.  
         [0187]    The above description relates to resource managers in the form of database systems. The described method can also be applied in other areas such as messaging systems. In a messaging system, it may be desirable to write several messages in parallel.  
         [0188]    In messaging systems, updates of messages are not carried out, a new message is simply written. So there is no reading step before an update and therefore no reading delay. Messaging systems are also different in that messages are usually read from the beginning or end of a queue. In database systems, it cannot be anticipated where a read will happen. Therefore, in messaging systems the beginning or end of the queue can already be in the buffer ready for reading. For these reasons, the invention is likely to be more advantageous to database systems than to messaging systems.  
         [0189]    The method described above of dealing with conflicts between operations in a database system, could be applied to operations in the form of messages in a messaging system, as both use similar underlying locking techniques.  
         [0190]    There are some differences. For example, messaging systems do not typically make detailed assurances about the ordering of messages written by different parallel transactions, but require that messages written within a transaction are saved and (subsequently returned to other transactions) in the order written. Messaging systems do not therefore typically need to hold locks on queues between one write operation and another; the operations within one transaction occur sequentially and fall naturally into order, and there is no ordering between transactions. However, it will be necessary to hold such write locks in order to support this invention, to assure appropriate sequencing between operations implemented in parallel by a single transaction. These locks will behave as for databases when potential conflicts occur within a transaction (xid/seqx and xid/seqy), but NO action will be taken for potential conflicts between transactions (xid1/seqx and xid2/seqy).  
         [0191]    Improvements and modifications can be made to the foregoing without departing from the scope of the present invention.