JP4261609B1 - トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システム - Google Patents

Abstract

【課題】
数多くのトランザクションを効率よく同時に処理するために、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システムを提案する。
【解決手段】
入力された複数のトランザクションを別々に処理するのではなく、入力された複数のトランザクションが処理を行うデータ項目に対して、そのデータ項目を一度だけ検索し、検索したデータ項目に対して、複数のトランザクションの更新処理を順次メインメモリ内で行い、最後に更新した結果だけをデータベースに一度だけ書き込むことを用いる。
複数の合成トランザクションの処理を同時に並行して実行するために、トランザクションの同時実行制御を備えたマルチオペレーションに、二相ロックを用いたマルチオペレーション・プロセッシングと、タイムスタンプを用いたマルチオペレーション・プロセッシングを用いている。
【選択図】図１

Description

本発明は、データベースのトランザクション同時実行制御に関し、特に、複数のトランザクションが同時に同一のアクセス領域に対して更新処理を行う場合に関するものである。

データベース・マネージメント・システムは、複数のユーザーからネットワークを経由して入力される数多くのトランザクションの処理を同時に並行して実行している。しかし、複数のトランザクションが同時に、同一のデータ項目に対して処理を行うと、データの矛盾が発生する場合があるため、データベース・マネージメント・システムは、データの矛盾が起こらないようにするために、トランザクションの同時実行制御を用いて、複数のトランザクションの処理を行っている。

＜直列可能スケジュール＞
複数のトランザクションをデータの矛盾が起こることなく処理するにあたって、最も簡単な手法は、トランザクションを１つずつ順番に処理していくことである。この手法は直列スケジュール(serial schedule)と呼び、１つのトランザクション処理が完全に終了してからでないと、次のトランザクションの処理を始めない手法である。しかし、この手法は、複数のトランザクションの処理を同時に平行して行うことができないため、１つのトランザクションがディスクへのＩ／Ｏ処理を完了するまで待っている間、ＣＰＵ処理を他のトランザクションに切り替えることができないなど、重要なＣＰＵ処理時間を無駄にすることになる。
そのため、複数のトランザクションを、データの矛盾が起こることなく、同時に平行して実行するには、直列可能スケジュール（serializable schedule）という手法が用いられる。

直列可能スケジュールを行うには、各トランザクションが処理を行うデータ項目に対してロックをかける手法が用いられる。ロックには、共有ロックと専有ロックがある。共有ロックは、トランザクションがデータを読み取るためだけにかけるロックである。１つのトランザクションがあるデータ項目を読み取るために共有ロックをかけると、他のトランザクションは、そのデータ項目を読み取ることはできるが、更新や削除することは、その共有ロックが解除されるまでできない。専有ロックは、データを更新するときにかけるロックである。１つのトランザクションがあるデータ項目を更新するために専有ロックをかけると、他のトランザクションは、その専有ロックが解除されるまで、そのデータ項目を更新、削除、及び読み取ることはできない。
ただし、ロックを用いただけでは、ロックをかける順番によっては、複数のトランザクション間でデータの矛盾が発生する場合がある。そのため、複数のトランザクションが同一のデータ項目に対してロックをかける場合、ロックをかけた順番に、それらのトランザクションに対して従属グラフを作成する手法が用いられる。従属グラフにサイクルが存在する場合は、複数のトランザクション間でデータの矛盾が発生したことになり、すべてのトランザクションの処理を中断し、中断したトランザクションの処理を再度始めから行うことになる。なお、従属グラフにサイクルが存在しない場合は、すべてのトランザクションの処理が矛盾なく実行されたことになる。
しかし、この手法だと、従属グラフにサイクルが発生する度に、トランザクションの処理が繰り返して中断されるため効率的ではない。また、何度もトランザクションの処理を繰り返しても直列可能スケジュールで行われない場合もある。そのため、直列可能スケジュールを保障するプロトコルとして、二相ロック・プロトコル、楽観的ロック・プロトコル、タイムスタンプ・プロトコル、マルチバージョン・プロトコルなどが用いられる。

(1)二相ロック・プロトコル
二相ロック・プロトコルは、各トランザクションの中のロック操作を、ロックをかける操作だけからなる成長相(growing phase)と、ロックをはずす操作だけからなる縮退相(shrinking phase)の２つの部分に分離して行う。したがって、ロックを解除した後に、再びロックをかけることは許されない。また、成長相ではロックをかける操作以外にロックのアップグレードが許され、縮退相ではロックを解く操作以外にロックのダウングレードが許される。直列可能スケジュールを行うには、すべてのトランザクションが二相ロック・プロトコルに従う必要がある。

二相ロック・プロトコルは、複数のトランザクションがお互いに必要なロックをかけて、どのトランザクションも処理できなくなると、デッドロックが発生することがある。デッドロックをはずすには、ロックをかけているトランザクションの１つを中断してロールバックし、中断したトランザクションをトランザクション同時処理ステムに再提出する。また、中断したトランザクションが書き込んだデータを別のトランザクションが使用していた場合、その別のトランザクションも中断してロールバックすることになる。このように、１つのトランザクションが中断することによって、いくつものトランザクションが連鎖的にロールバックすることを連鎖的ロールバック(cascading rollback)と呼ぶ。連鎖的ロールバックが起こらないようにするには、厳格な二相ロック・プロトコルという手法を用いる。この手法は、二相ロック・プロトコルの縮退相における最初のロックをはずす操作はトランザクションがコミットまたは中断(abort)した後であるという条件をさらに付け加えたものである。この手法を用いると、連鎖的ロールバックは起こらなくなるが、個々のトランザクションがロックをかけておく時間が長くなる。

<二相ロックの問題点>
二相ロック・プロトコルは、同時に処理するトランザクションの数が増えると、複数のトランザクションの間でロックをかけるために競合が起こり、デッドロックが起こりやすくなる。その結果、デットロックをはずすために数多くのトランザクションが中断してロールバックすることになり、トランザクションの処理速度を低下させることになる。
二相ロック・プロトコルは、複数のトランザクションが同時に、同じデータ項目に対して処理を行う必要がある場合、個々のトランザクションごとに、そのデータ項目に対して何度も繰り返してロックをかけることになる。そして１つのトランザクションがあるデータ項目に対してロックをかけている間、そのデータ項目に対して処理を行う他のトランザクションは、そのロックが解除されるまで待たされることになる。

二相ロック・プロトコルは、個々のトランザクションに対して、オペレーティング・システムのプロセスを用いて処理を行っている。１つのトランザクションが、あるデータ項目に対してロックをかけた状態で、オペレーティング・システムによるプロセスの切り替えが起こると、ロックされたそのデータ項目に対して処理を行う他のトランザクションは、CPU（マイクロプロセッサ)で処理される時間を得ても、そのデータ項目に対してロックをかけることができないため、何も処理を行うことができないまま、再びプロセスの切り替えが起こる。同時に処理するトランザクションの数が増えると、このような状態が繰り返して起こるようになり、トランザクションの処理速度を著しく低下させることになる。

(2) 楽観的ロック・プロトコル
楽観的ロック(optimistic locking protocol)は、トランザクションを実行するのに競合がないものと仮定して処理を行い、トランザクションが終了するときに、競合があったかどうかを確認し、競合があったならば、トランザクションを中断してロールバックする。競合がなかったならば、その時点でデータを書き込むデータ項目に対してロックをかけ、書き込み処理を実行し、トランザクションをコミットする。この手法はトランザクションの処理が行われている間、ロックをかけたままの状態にしておく必要がなく、ロックをかけておく時間はトランザクションがコミットする前の短い時間だけですむ。

<楽観的ロック・プロトコルの問題点>
楽観的ロック・プロトコルも二相ロック・プロトコルと同様に、同時に処理するトランザクションの数が増えると、データを更新するために競合するトランザクションの数が増え、中断してロールバックするトランザクションの数も増えるといった問題点がある。

(3) タイムスタンプ・プロトコル
タイムスタンプ・プロトコルは、複数のトランザクションを同時に並行して処理するにあたって、個々のトランザクションにタイムスタンプ（到着時間)を与え、タイムスタンプの小さい(到着時間の早い)トランザクションからタイムスタンプの大きい(到着時間の遅い)トランザクションへと順番に実行していく手法である。そのためには、トランザクションが処理を行う個々のデータ項目に対して、読み込みタイムスタンプと書き込みタイムスタンプを与えて、次の規約に従ってトランザクション処理を行う。

当面のトランザクションが、あるデータ項目に対して読み込む処理を行うとき、当面のトランザクションのタイムスタンプとそのデータ項目の書き込みタイムスタンプを比べ、当面のトランザクションのタイムスタンプの方が小さければ、当面のトランザクションが読み込むべきデータ項目の値がすでに失われているので、当面のトランザクションを中断する。それ以外のときは、当面のトランザクションの処理を実行し、そのデータ項目の読み込みタイムスタンプに、当面のトランザクションのタイムスタンプを与える。

当面のトランザクションが、あるデータ項目に対して書き込み処理を行うとき、当面のトランザクションのタイムスタンプとそのデータ項目の読み込みタイムスタンプを比べ、当面のトランザクションのタイムスタンプの方が小さければ、当面のトランザクションが書き込み処理を行ったあとのデータ項目の値を読み取るべきトランザクションが、先にそのデータ項目を読み取ってしまっているので、当面のトランザクションを中断する。また、当面のトランザクションが、そのデータ項目の読み込みタイムスタンプよりも大きく、そのデータ項目の書き込みタイムスタンプよりも小さければ、当面のトランザクションは、書き込み処理の時機を逸しているので中断する。それ以外のときは、当面のトランザクションを実行し、当面のトランザクションのタイムスタンプの方がそのデータ項目の書き込みタイムスタンプよりも大きければ、そのデータ項目の書き込みタイムスタンプに、当面のトランザクションのタイムスタンプを与える。
なお、中断したトランザクションは、ロールバックし、トランザクション処理システムに再提出し、新たなタイムスタンプが与えられることになる。

タイムスタンプ・プロトコルは、中断されるトランザクションの数を減らすために、トーマスの書き込みルール(Thomas's write rule)という手法を用いることができる。この手法は、トランザクションがあるデータ項目に書き込み処理を行うとき、当面のトランザクションのタイムスタンプが、そのデータ項目の読み込みタイムスタンプよりも大きく、そのデータ項目の書き込みスタンプよりも小さければ、当面のトランザクションは、書き込み処理の時機を逸してしまっているが、そのことによるデータベース及び他のトランザクションへの影響はないので、当面のトランザクションはこの書き込み処理を無視して処理を続ける手法である。

<タイムスタンプ・プロトコルの問題点>
タイムスタンプ・プロトコルはロックを使用しないため、デッドロックが起こることはない。しかし、同時に処理するトランザクションの数が増えると、個々のデータ項目に対して、正しい順番でトランザクションの処理が行われなくなり、数多くのトランザクションが中断してロールバックし、トランザクション処理システムに再提出されることになる。このような処理が繰り返されると、いつまでたってもトランザクションの処理が完了しなくなるといった問題が起こる。

(4) マルチバージョンを用いた手法
マルチバージョンを用いた手法は、当面のトランザクションがあるデータ項目に対して、データを書き込む際に、そのデータ項目の前の値を維持し、１つのデータ項目に対して複数の値を管理する手法である。そして、複数のトランザクションが、同じデータ項目に対して処理を行う場合、個々のトランザクションに対して、適切なバージョンのデータ項目を与えることによって、中断されるトランザクションの数を減らしている。マルチバージョンを用いた手法は、二相ロック・プロトコルにマルチバージョンを適用させた手法と、タイムスタンプ・プロトコルにマルチバージョンを適用させた手法などがある。

<マルチバージョンの問題点＞
マルチバージョンの問題点は、個々のデータ項目に対して複数のバージョンを維持するために余分な記憶スペースが必要になることである。

特開平０７−０８４８６４号公報 特開平０７−２００３７２号公報 特開平１０−３２０２５８号公報 特開２００２−３２２４９号公報 United States Patent 5,280,619 January 18, 1994 System for accessing shared data using a serialization graph constructed from a history file showing completed locking dependencies between transactions 北川博之 HIROYUKI KITAGAWA, データベースシステム Database System, pp.147-173, 昭晃堂 情報系教科書シリーズ 第１４巻, １９９６年７月１０日 初版１刷発行 1997 Ramez Elmasri, Shamkant B. Navathe, Fundamentals of Database Systems Second Edition, pp.527-575, Addison-Wesley Publishing Company, 1994 金弘和實 KAZUIMI KANEHIRO, ベテランが丁寧に教えてくれるデータベースの知識と実務, pp.88-105, 株式会社翔泳社, 2007

従来のトランザクション処理システムは、以上に述べた問題点があるため必ずしも効率的な手法ではない。従来の手法は、個々のトランザクションを別々に処理するため、同時に処理するトランザクションの数が増えると、個々のトランザクションごとに、同じデータ項目を何度も繰り返して読み出し、そして書き込むことになり、複数のトランザクションが競合し、中断してロールバックするトランザクションが増えて、トランザクションの処理速度が低下することになる。

本発明では、入力された複数のトランザクションを別々に処理するのではなく、入力された複数のトランザクションが処理を行うデータ項目に対して、そのデータ項目を一度だけ検索し、検索したデータ項目に対して、複数のトランザクションの更新処理を順次メインメモリ内で行い、最後に更新した結果だけをデータベースに一度だけ書き込むことを用いる。

上述の目的を達成するために、本発明は、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システムであって、入力された複数のトランザクションに対してトランザクションの実行順を決定するトランザクション実行順決定手段と、前記複数のトランザクションが同一のデータ項目に対して処理を行う場合、そのデータ項目に対する枝を作成し、先に処理を行うトランザクションの接点から次に処理を行うトランザクションの接点にその枝を入力して、前記トランザクションの実行順にデータを更新することを示した先行グラフを作成する先行グラフ作成手段と、前記複数のトランザクションに含まれる部分処理をタスクとして取り出すタスク取り出し手段と、前記取り出したタスクを、前記トランザクションの実行順に、前記データベースのアクセス領域ごとにグループ分けするグループ分け手段と、前記グループ分けして作成したグループを用いて合成トランザクションを作成する合成トランザクション作成手段と、前記合成トランザクションに含まれる個々のグループに対してマルチオペレーション・プロセッシングを用いて処理を行うマルチオペレーション・プロセッシング手段とを備え、前記マルチオペレーション・プロセッシング手段は、グループ分けされたタスクがアクセスするアクセス領域内のブロックを調べ、グループ内のタスクが並んでいる順に該ブロックへのアクセス順を決定し、決定したアクセス順に該ブロックを読み出し、読み出したブロックにアクセスするタスクをグループ内から抽出し、ブロック内のデータ項目に対して、グループ内のタスクが並んでいる順にタスク処理を順次行い、グループ分けされたタスクの処理が終了し、グループ分けされたタスクを包含するトランザクションの処理が終了すると、その時点で終了したトランザクションをコミットするかどうかを、前記先行グラフの終了したトランザクションの接点に入力枝が存在するかどうかで決定し、該トランザクションの接点に入力枝が存在しない場合は、該トランザクションをコミットし、該トランザクションの接点とその接点から出ているすべての枝を削除し、ブロック内のデータ項目に対して、グループ内のタスクが並んでいる順にタスク処理を順次行っていくということは、ブロック内のデータ項目が前記先行グラフに存在する場合、そのデータ項目に対して前記先行グラフに示したトランザクションの実行順にトランザクションの部分処理であるタスクの処理を順次行っていくことであり、複数のタスクがそのデータ項目に対して更新処理を行う場合、そのデータ項目に対して最初のタスクの更新処理を行い、更新されたデータ項目に対して次のタスクの更新処理を行い、このような更新処理を繰り返し、最後のタスクの更新処理が行われると、最後に更新された更新結果だけをデータベースに書き込むことを特徴とする。

また、２相ロック・プロトコル又はタイムスタンプ・プロトコルを用いて複数の合成トランザクションの処理を同時に並行して実行するとよい。
さらに、データベースのトランザクション処理システムの各機能を、コンピュータ・システムに実現させるためのプログラムや、このプログラムを記録した記録媒体も本発明である。

本発明のトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いることによって、従来のトランザクションの処理のように、入力された複数のトランザクションに対して、トランザクションごとに同じデータ項目を何度も繰り返して検索し、検索したデータ項目に対して更新処理を別々に行い、更新された結果を何度も繰り返してデータベースに書き込む必要がなくなった。
本発明のシステムでは、複数のトランザクションが処理を行うデータ項目に対して、そのデータ項目を一度だけ検索し、検索したデータ項目に対して、複数のトランザクションの更新処理を順次メインメモリ内で行い、最後に更新した結果だけをデータベースに一度だけ書き込めばよいのでトランザクションの処理速度が向上した。
また、マルチオペレーション・プロセッシングを用いるので、トランザクションの処理を行う個々のデータ項目が格納してあるブロックをディスクから一度だけしか読み出す必要がなくなった。

本発明のシステムは、入力された複数のトランザクションに対して１つの合成トランザクションを作成し、合成トランザクションに含まれる個々のグループの処理は、異なるリレーションに対して行うため、それらのグループの処理を同時に行っても、複数のグループ間で同一のデータ項目がアクセスされることはない。また、グループに集められたタスクの処理は、メインメモリに読み込まれたブロック内のデータ項目に対して、先行グラフに示したトランザクションの実行順に順次行っていく。その結果、合成トランザクションに合成された複数のトランザクションの間でロックなどをかける必要はなく、トランザクションを待たせたり、トランザクションを中断したりするといったことがなくなった。

本発明のシステムは、入力された複数のトランザクションに対して１つの合成トランザクションを作成し、合成トランザクションの処理を行っていくことができ、１つの合成トランザクションの処理が終了した段階で、新たに複数のトランザクションが入力されると、それらのトランザクションに対して別の合成トランザクションを作成し、その合成トランザクションの処理を行っていくことができるので、合成トランザクションの処理を１つずつ実行していく場合には、ロックを用いる必要はなくなる。また、デッドロックなどを発生することもなく、合成トランザクションに含まれる複数のグループの処理を同時に並行して実行していくことができるようになった。

このように合成トランザクションの処理を１つずつ実行していくことによって、複数のトランザクションの処理速度を向上させることができるが、複数の合成トランザクションの処理を同時に並行して実行することが必要となるような場合には、複数の合成トランザクションに二相ロックやタイムスタンプを用いたマルチオペレーション・プロセッシングを使用することによって、CPUやディスクなどのハードウェア資源を効率よく利用することができるようになった。また従来の二相ロック・プロトコルのように、個々のトランザクションがそれぞれロックをかけるのではなく、数多くのトランザクションから作成された合成トランザクションがロックをかけることになるので、オペレーティング・システムのプロセスやロックなどの資源利用の回数を減少させることができるようになった。

本発明は、数多くのトランザクションを効率よく同時に処理するために、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システムを提案する。さらに、本発明は、複数の合成トランザクションの処理を同時に並行して実行するために、トランザクションの同時実行制御を備えたマルチオペレーションに、二相ロックを用いたマルチオペレーション・プロセッシングと、タイムスタンプを用いたマルチオペレーション・プロセッシングを提案する。

本発明者は、以前クエリーの処理だけを扱った「マルチオペレーション・プロセッシングを用いたデータベースのクエリー処理システム」について提案した（特許４１０９３０５号参照）。
本発明のトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングが上記のクエリーの処理だけを扱ったマルチオペレーション・プロセッシングと異なる点は、検索処理しか行わないトランザクション（クエリー）の処理以外に、更新処理を行うトランザクションの処理を行うことができるようになったことである。

<データベース・マネージメント・システムの構成>
図１は、本発明のトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システムのアーキテクチャを示す図である。このアーキテクチャは、マイクロプロセッサ（ＣＰＵ）、主記憶装置（メインメモリ）、２次記憶装置（ディスク）を備えたコンピュータ・システム105において、トランザクション処理システム100、キュー103、マルチオペレーション・プロセッサ102などのソフトウェアのモジュールから構成されている。

最初に、複数のユーザーからSQLなどの言語で記述された複数のトランザクションT₁,T₂,…,T₈がトランザクション処理システム100に入力されると、トランザクション処理システムは、入力されたトランザクションに対して、トランザクションの部分処理を求めてトランザクションの実行順を決定し、トランザクションの実行順にデータを更新することを示した先行グラフを作成し、トランザクションに含まれる部分処理をタスクとして取り出し、取り出したタスクをデータベースのリレーション(アクセス領域)ごとにグループG1,G2に分けて、グループG1,G2を作成し(トランザクションT₁,T₂,…,T₈が合計２つのリレーションに対して処理を行う必要がある場合)、作成したグループG1,G2を用いて合成トランザクションT_G1,G2を作成し、合成トランザクションT_G1,G2をキュー103に加える。

キュー103に合成トランザクションT_G1,G2が加えられると、マルチオペレーション・プロセッサ102は、キュー103から合成トランザクションT_G1,G2を取り出し、オペレーティング・システムのプロセス(104)が５つほどをトランザクション処理システムのために用意されていた場合、プロセス１がT_G1,G2に含まれるグループG1に対してマルチオペレーション・プロセッシングを用いて処理を行い、プロセス２がT_G1,G2に含まれるグループG2に対してマルチオペレーション・プロセッシングを用いて処理を行うことになる。

次に、合成トランザクションT_G1,G2がキューから取り出された後に、新たにトランザクションT₉,T₁₀,T₁₁がトランザクション処理システム100に入力されると、トランザクションT₉,T₁₀,T₁₁に対しても同様に、トランザクション処理システム100は、入力されたトランザクションに対して、トランザクションの部分処理を求めてトランザクションの実行順を決定し、トランザクションの実行順にデータを更新することを示した先行グラフを作成し、トランザクションに含まれる部分処理をタスクとして取り出し、取り出したタスクをデータベースのリレーションごとにグループG3,G4,G5に分けて、グループG3,G4,G5を作成し(トランザクションT₉,T₁₀,T₁₁が合計３つのリレーションに対して処理を行う必要がある場合)、作成したグループG3,G4,G5を用いて合成トランザクションT_G3,G4,G5を作成し、合成トランザクションT_G3,G4,G5をキュー103に加える。

マルチオペレーション・プロセッサ102は、現在プロセス１とプロセス２を用いて合成トランザクションT_G1,G2の処理を行っていたとすると、残ったプロセス３とプロセス４とプロセス５を用いて合成トランザクションT_G3,G4,G5のグループG3,G4,G5の処理を行うことになる。

＜マルチオペレーション・プロセッシングを用いたトランザクション処理システムのフローチャート＞
図２−１，図２−２は、図１で説明したトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システムにおいて、トランザクションを処理する一連の流れの概略を説明するためのフローチャートである。

最初に、図２−１において、複数のユーザーからSQL(構造化問い合わせ言語)などのリレーショナル・データベースの言語で記述された複数のトランザクションT₁,T₂,T₃,….,T_sがデータベース・サーバーのトランザクション処理システム１００に入力される(S200)。
トランザクション処理システム１００は、入力されたトランザクションに対して、実行可能なオペレーションに変換してトランザクションの部分処理を作成する(S201)。トランザクションの部分処理を作成すると、トランザクションの実行順を決定する(S202)。

トランザクションの実行順を決定すると、トランザクションT₁,T₂,….,T_sを接点とした先行グラフを作成する(S203)。先行グラフを作成するにあたって、トランザクションT₁,T₂,…,T_sの中で複数のトランザクションが同一のデータ項目に対して処理を行う場合、そのデータ項目に対して矢印を持った枝を作成し、先に処理を行うトランザクションの接点から次に処理を行うトランザクションの接点へとその枝を入力させて、そのデータ項目に対するトランザクションの実行順を明確にする。
先行グラフを作成すると、トランザクションに含まれる部分処理をタスクとして取り出し、取り出したタスクをデータベースのリレーション（アクセス領域）ごとにグループ分けして、グループG1,G2,…,Gnを作成する(S204)。
作成されたグループG1,G2,…,Gnを用いて合成トランザクションT_G1,G2,…,Gnを作成する(S205)。

合成トランザクションT_G1,G2,…,Gnに含まれる個々のグループGi(i=1,2,..,n)に対して、マルチオペレーション・プロセッサ１０２を用いてグループの処理を開始する(S206)。
マルチオペレーション・プロセッッサ１０２は、グループ内のタスクがアクセスするブロックを調べてブロック集合に集める(S207)。
ブロック集合にブロックを集めると、グループ内のタスクが並んだ順にブロックへのアクセス順を決定する(S208)。
決定したブロックのアクセス順にブロックを読み出し、読み出したブロックにアクセスするタスクをグループから抽出し、ブロック内のデータ項目に対して、グループ内のタスクが並んだ順にタスク処理を順次行っていく(S209)。
ブロックでタスクの処理が終了すると(図２−２：S210)、終了したタスクを包含するトランザクションの処理が終了したかどうかを調べる(S211)。トランザクションの処理が終了したかどうかは、トランザクションに含まれるすべてのタスクの処理が終了したかどうかで調べることになる。トランザクションの処理が終了しない場合は、ブロックのアクセス順に示したすべてのブロックをアクセスしたがどうかを確認する(S217)。

トランザクションの処理が終了した場合は、先行グラフをもとにして、この時点でトランザクションをコミットすることができるかどうかを決定する(S212)。トランザクションをコミットすることができるかどうかは、先行グラフにおいて、終了したトランザクションの接点に入力枝が存在するかどうかで調べることになる。
終了したトランザクションの接点に入力枝が存在し、この時点でトランザクションをコミットできない場合は、そのトランザクションをコミット待ちのトランザクションとして置いておく（S216）。

入力枝が存在しないで、トランザクションをコミットすることができる場合は、トランザクションをコミットし(S213)、そのトランザクションの接点とその接点から出ているすべての枝を先行グラフから削除する(S214)。また、枝を削除することによって、別のコミット待ちのトランザクションの接点に入力している枝がすべて無くなる場合は(S215)、そのトランザクションもコミットし、連鎖的にトランザクションのコミットを繰り返していく(S213)。
アクセスしたブロックでの処理が終了すると、ブロックのアクセス順に示したすべてのブロックをアクセスし終えたかどうかを確認する(S217)。
まだ、アクセスしてないブロックが残っているならば、ブロックのアクセス順に、次にアクセスするブロックをディスクから読み出し、読み出したブロックにアクセスするタスクをグループから抽出し、読み出したブロック内のデータ項目に対して、トランザクションの実行順にトランザクションの部分処理であるタスク処理を繰り返して行っていく(S209)。

ブロックのアクセス順に示したすべてのブロックをアクセスし終えると、グループの処理が終了する(S218)。グループの処理が終了すると合成トランザクションに含まれるすべてのグループの処理が終了したかどうかを確認する(S219)。
まだ、グループが残っている場合は、次に処理するグループを合成トランザクションから取り出し、取り出したグループに対して、マルチオペレーション・プロセッシングを用いて処理を行い、このようにしてグループの処理を繰り返して行っていく(S206)。
合成トランザクションに含まれるすべてのグループ処理を終えると、合成トランザクションの処理が完了し、入力されたすべてのトランザクションT₁,T₂,T₃,…,T_sの処理が終了してコミットしたことになる(S220)。

図１，図２−１，図２−２において、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングの概略を説明した。
以下の章において、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システムについて詳しく説明していくことにする。
第１章では、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたトランザクション処理の手順、及び具体例を示している。第２章では、複数の合成トランザクションを同時に並行して実行するために、二相ロックを用いたマルチオペレーション・プロセッシングとタイムスタンプを用いたマルチオペレーション・プロセッシングを提案し、それぞれの手法を用いた複数の合成トランザクションの処理を並行して行うための手順、及び具体例を示している。第３章では、結合演算の処理を行うクエリーなど、複雑で高度なクエリーがトランザクションに含まれている場合のマルチオペレーション・プロセッシングを具体例をもとに説明している。
第４章では、従来のトランザクションの処理である二相ロック・プロトコルと、本発明のトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングとの処理速度を比較するために、独自に開発したデータベース・マネージメント・システムのソフトウェアMOP-DBを用いて、それぞれの処理を用いた実験結果を示している。

[1. トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシング]
[1.1トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングの手順]
[(1) トランザクションの部分処理の作成（S201）]
データベース・マネージメント・システムに、複数のトランザクションT₁,T₂,T₃,…,T_sが入力される（S200)と、個々のトランザクションに対して、トランザクションが行うレコードrの読み取り処理をread_item(r)とし、レコードrの書き込み処理をwrite_item(r)として表わしたトランザクションの部分処理を作成する（S201）。

[(2) トランザクションの実行順の決定（S202）]
トランザクションの部分処理を求めると、入力された複数のトランザクションT₁,T₂,T₃,…,T_sに対して、トランザクションの実行順を決定する（S202）。トランザクションの実行順を決定するには、トランザクションの部分処理をもとにしてトランザクションの処理コストを求め、処理コストの小さいトランザクションから処理コストの大きいトランザクションへとトランザクションを並べてトランザクションの実行順を決定する。
なお、トランザクションの処理コストよりも、トランザクションの到着時間の方が重要である場合は、トランザクションの到着順をトランザクションの実行順にしてもよい。

[(3) 先行グラフの作成（S203）]
トランザクションの実行順を決定すると、トランザクションT₁,T₂,T₃,…,T_sを接点とした先行グラフを作成する（S203）。先行グラフを作成するにあたって、トランザクションT₁,T₂,T₃,…,T_sの中で、複数のトランザクションが同一のデータ項目に対して処理を行う場合、そのデータ項目に対して矢印を持った枝を作成し、トランザクションの実行順に、先に処理を行うトランザクションの接点から、次に処理を行うトランザクションの接点へと、その枝を入力する。
トランザクションの実行順が、トランザクションの処理コストの小さい順で並べられている場合は、処理コストの小さいトランザクションの接点から処理コストの大きいトランザクションの接点へと、枝を入力することになる。また、トランザクションの実行順が、トランザクションの到着順で並べられている場合は、先に到着したトランザクションの接点から次に到着したトランザクションの接点へと枝を入力することになる。

[(4) タスクのグループ分け（S204）]
トランザクションT₁,T₂,T₃,…,T_sに含まれる個々の更新処理、及び検索処理などの部分処理をタスクt_i ^j(i=トランザクションの番号、j=トランザクション内の処理番号)として取り出し、取り出したタスクを、トランザクションの実行順にデータベースのリレーション(アクセス領域)ごとにグループG1,G2,…,Gnとしてグループに分けていく（S204）。リレーションはデータベースのアクセス領域である。

[(5) 合成トランザクションの作成（S205）]
タスクがリレーションごとにグループ分けされると、作成されたグループG1,G2,…Gnを用いて合成トランザクショT_G1,G2,…Gnを作成する（S205）。合成トランザクションT_G1,G2,…Gnの処理を行うには、マルチオペレーション・プロセッシングを用いて合成トランザクションT_G1,G2,…Gnに含まれる個々のグループ処理を順次行っていくことになる。

[(6) マルチオペレーション・プロセッシングによるグループ処理]
最初に、合成トランザクションT_G1,G2,…GnからグループG1を取り出し、マルチオペレーション・プロセッシングを用いてグループG1の処理を開始する（S206）。

[(7) タスクのアクセス領域の検出]
グループG1内のタスクt₁, t₂, t₃,…,t_pがアクセスするリレーションに存在するインデックスを用いて、グループG1内のタスクt₁, t₂, t₃,…,t_pが、リレーション内のブロックb₁,b₂,b₃,…b_mのうちアクセスする必要のあるブロック(ブロックの格納位置)を調べて、アクセスする必要のあるブロックを集めた集合を見出し、それらの集合をそれぞれブロック集合B₁,B₂,B₃,…B_pとする（S207）。言い換えると、タスクt_i(i=1,2,3,…p) に対して、それに対応するブロック集合として、B_i={ブロックb₁,b₂,b₃,…,b_mの中でタスクt_iがアクセスする必要があるブロック集合}{i=1,2,3,…,p}となるブロック集合を見出す。ここでブロック集合を見出すにあたっては、インデックスによるブロックの格納位置を調べるだけであって、リレーション内のブロックをディスクにアクセスしてブロックの格納位置を調べることではない。

[(8) ブロックのアクセス順位の決定（S208）]
グループG1内のタスクt₁, t₂, t₃,…,t_pに対応するブロック集合B₁,B₂,B₃,…B_pを見出すと、ブロック集合B₁,B₂,B₃,…,B_pの和集合を求めていく。最初に、タスクt₁とタスクt₂に対応するブロック集合との和集合を求め、その和集合とタスクt₃に対応するブロック集合との和集合を求めるということを順次行い、最後にタスクt_pに対応するブロック集合との和集合を求める。この際、順次和集合に加わるブロックは和集合中のブロックの後に加えるものとする。最後に求めた和集合の結果から、トランザクションの実行順に、トランザクションの部分処理であるタスク処理を行っていくにあたって、最初にリレーション内のどのブロックからアクセスを始めて、最後にどのブロックでアクセスを終えるかのブロックのアクセス順位を決定することができる（S208）。また、このようにして和集合を求めることは、グループ内のタスクを処理するにあたって、リレーション内のブロックを何度もディスクにアクセスして読み出すことなしに、一度だけブロックにアクセスすれば済むようにするためである。

[(9) 各ブロックでのタスク処理（S209)]
[ブロック b_jでのタスク処理]
決定されたブロックのアクセス順位に従って、リレーションにアクセスする最初のブロックをb_j(1≦j≦m)としたときに、グループG1内のタスクt₁,t₂,t₃,…,t_pをこのブロックで処理を行う必要があるかどうかを調べるためにブロックb_jを集合{b_j}として表わし、この{b_j}とタスクt₁,t₂,t₃,…,t_pに対応するブロック集合B₁,B₂,B₃,…,B_pとの間で積集合(∩)を求める。その積集合が{b_j}となったブロック集合に対応するタスクはすべてブロックb_jで処理を行うことになり、積集合が空集合({})となったブロック集合に対応するタスクはブロックb_jで処理を行わないことになる。なお、複数のタスクがブロックb_j内の同一のデータ項目に対して処理を行う場合は、先行グラフに示したトランザクションの実行順に、それらのトランザクションの部分処理であるタスク処理を順次行っていく。
ブロックb_jで処理を行う必要のあるグループG1のすべてのタスクの処理が終了すると、このブロックb_jを再びアクセスする必要がなくなるので、積集合{b_j}となったブロック集合と集合{b_j}との差集合を求めて、差集合によって得られたブロック集合をB_i ⁽¹⁾(i=1,2,…,p)としたときに、その差集合B_i ⁽¹⁾が空集合({})となったブロック集合に対応するタスクは処理が終了（S210)したことになり、その差集合が空集合でないブロック集合に対応するタスクはまだ処理が終了していないことになる。

[トランザクションの終了、及びコミット]
ブロックb_jでのタスクの処理が終了すると、終了したタスクを包含するトランザクションの処理が終了したかどうかを確認する（S211)。トランザクションに含まれるすべてのタスクの処理が終了する（S211：YES)と、トランザクションの処理が終了することになる。トランザクションの処理が終了すると、この時点で終了したトランザクションをコミットすることができるかどうかを、先行グラフをもとにして決定する（S212）。
終了したトランザクションの接点に入力している枝が存在する場合（S212：NO）は、そのトランザクションをコミットしないで、コミット待ちのトランザクションとして置いておく（S216）。終了したトランザクションの接点に入力している枝が１つも存在しない場合（S212：YES）は、そのトランザクションをコミットする（S213）。トランザクションをコミットすると、先行グラフからそのトランザクションの接点と、その接点から出ているすべての枝を削除する（S214）。

その際、削除した枝がコミット待ちのトランザクションの接点に入力している枝であり、その枝を削除することによって、コミット待ちのトランザクションの接点に入力している枝が１つもなくなる場合（S215：YES）は、そのコミット待ちのトランザクションもコミットすることになる（S213）。その理由は、接点に入力している枝がなくなるということは、同じデータ項目に対して先に書き込み処理を行ったトランザクションがコミットしたため、その書き込まれたデータ項目を読み込んだ別のトランザクションもコミットすることができるからである。

[ブロック b_kでのタスク処理]
さて、すべてのブロックをアクセスしていない場合（S217:NO)、S209に戻り、ブロックのアクセス順位に従って、次のブロックb_k(1≦k≦m)を読み出し、ブロックb_kを集合{b_k}として表わし、この集合{b_k}と、すでに処理が終了したタスク以外のグループ内にタスクに対応するブロック集合の間で積集合を求める。その積集合が{b_k}となったブロック集合に対応するタスクはすべてブロックb_kで処理を行うことになる。ブロックb_kで処理を行う必要のあるグループG1内のすべてのタスクの処理が終了すると、ブロックb_kを再びアクセスすることがなくなるので、積集合が{b_k}となったブロック集合B_i ⁽¹⁾(ブロックb_jで処理終了後に差集合によって得られたブロック集合)と集合{b_k}との差集合を求める。この差集合が空集合({})となったブロック集合に対応するタスクは処理が終了したことになり、差集合が空集合ではないブロック集合に対応するタスクは、まだ処理が完全に終了していないことになる。ここで、差集合によって得られたブロック集合をB_i ⁽²⁾(i=1,2,…,n)とする。

[トランザクションの終了、及びコミット]
ブロックb_kにおいて、タスクの処理が終了する（Ｓ210)と、そのタスクを包含するトランザクションの処理が終了したかどうかを確認する（S211)。トランザクションに含まれるすべてのタスクの処理が終了すると、トランザクションの処理が終了したことになる。トランザクションの処理が終了すると、先行グラフをもとにして、終了したトランザクションをこの時点でコミットすることができるかどうかを決定する（Ｓ212)。
終了したトランザクションの接点に入力している枝が存在する場合（S212：NO）は、そのトランザクションをコミットしないでコミット待ちのトランザクションとして置いておく（S216）。終了したトランザクションの接点に入力している枝が１つも存在しない場合（S212：YES）は、トランザクションをコミットする（S213）。トランザクションをコミットすると、そのトランザクションの接点と、その接点から出ているすべての枝を先行グラフから削除する。

以上の処理を繰り返して行って、ブロックのアクセス順位にしたがってブロックをアクセスし、アクセスしたブロックでグループ内のタスクの処理を行うと、グループG1内のすべてのタスクの処理を終了する（S217：YES）。

[(10) マルチオペレーション・プロセッシングによるグループG2,…,Gnの処理]
グループG1の処理が終了する（S218）と、合成トランザクションT_G1,G2,…,GnからグループG2,…,グループGnを順次取り出し、グループG1と同じ手順を用いてグループ処理を繰り返して行っていく（S219：NO）。
すべてのグループ処理を終える（S219：YES）と、合成トランザクションT_G1,G2,…,Gnの処理が完了し、入力されたすべてのトランザクションT₁,T₂,T₃,…,T_sの処理が終了してコミットしたことになる（S220)。

[1.2. トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングの具体例]
１．１章で示したトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングの手順を具体的な例を用いて詳細に説明する。図３−１は、固定長レコード(fixed length record)を使用して作成したデータベースのリレーションDEPARTMENT(300)である。リレーションDEPARTMENT(300)には25件のレコードが5つのブロックに格納してあり、各ブロックに5つのレコードが存在する。各レコードには、DNUMBER（部門番号），DNAME（部門名），MGRSSN（部門長従業員番号），BUDGET(予算), DPHONE（部門電話番号）のデータが格納されている。各ブロックは、次のブロックに対してブロックポインタを持っている。主キーDNUMBERには、主インデックス(310)が存在し、主インデックス(310)は、各ブロックに対してインデックスのポインタを持っている。また属性DPHONEには２次インデックス(321,322)が存在し、２次インデックス(321,322)は、各レコードに対してインデックスのポインタを持っている。

図３−２は、固定長レコードを使用して作成したデータベースのリレーションEMPLOYEE（従業員）である。EMPLOYEE(400)には20件のレコードが5つのブロックに格納してあり、それぞれのブロックに4つのレコードが存在する。各レコードには、SSN（従業員番号），FNAME（名），MINIT（ミドルネームの頭文字），LNAME（姓），BDATE（生年月日）， DNUM（部門番号）， PHONE（電話番号）のデータが格納されている。各ブロックは、次のブロックに対してブロックポインタを持っている。主キーSSNには、主インデックス(410)が存在し、主インデックス(410)は、各ブロックに対してインデックスポインタを持っている。また属性PHONEには２次インデックス(420)が存在し、２次インデックス(420)は、各レコードに対してインデックスのポインタを持っている。

なお、図３−１のリレーションDEPARTMENT(300)と図３−２のリレーションEMPLOYEE(400)以外に、図では示していない１つのリレーションPROJECTがデータベースに存在するものとする。
リレーションDEPARTMENT(300), EMPLOYEE(400), PROJECTは、リレーショナル・データベース・システムのアクセス領域であり、リレーション内のブロックはデータベースのデータが格納してあるディスク上のアクセス単位である。

次に、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたトランザクション処理を説明するために、これらのリレーションに対して、下記に示すようなトランザクションT₁, T₂, T₃, T₄, T₅, T₆, T₇, T₈の処理を取り上げることにする。以下において、各トランザクションは、BEGINで開始し、COMMITで完了することにする。

(T₁):BEGIN WORK;
-- T₁の更新処理１
UPDATE DEPARTMENT
SET BUDGET = BUDGET + 10000
WHERE DNUMBER = 7;
-- T₁の更新処理２
UPDATE DEPARTMENT
SET BUDGET = BUDGET + 20000
WHERE DNUMBER = 9;
-- T₁の更新処理３
UPDATE EMPLOYEE
SET DNUM = 4
WHERE SSN = 2411111133;
COMMIT WORK;

(T₂):BEGIN WORK;
-- T₂の更新処理１
UPDATE DEPARTMENT
SET BUDGET = BUDGET + 22000
WHERE DPHONE = 23-3728;
-- T₂の更新処理２
UPDATE DEPARTMENT
SET BUDGET = BUDGET + 30000
WHERE DNUMBER > 6 AND DNUMBER < 9;
COMMIT WORK;

(T₃):BEGIN WORK;
-- T₃の更新処理１
UPDATE DEPARTMENT
SET MGRSSN = 470124116
WHERE DNUMBER = 6 OR DNUMBER = 19;
-- T₃の検索処理２
SELECT DNUMBER, DNAME
FROM DEPARTMENT
WHERE DNUMBER = 19;
COMMIT WORK;

(T₄):BEGIN WORK;
-- T₄の更新処理１
DATE DEPARTMENT
SET DPHONE = 23-3736
WHERE DNUMBER = 3;
-- T₄の更新処理２
UPDATE DEPARTMENT
SET DPHONE = 23-3737
WHERE DNUMBER = 19;
-- T₄の更新処理３
UPDATE EMPLOYEE
SET BDATE = 'DEC-27-1971'
WHERE SSN = 2066567788;
COMMIT WORK;

(T₅):BEGIN WORK;
-- T₅の更新処理１
UPDATE DEPARTMENT
SET BUDGET = BUDGET - 24000
WHERE DNUMBER = 7 OR DNUMBER = 8;
-- T₅の更新処理２
UPDATE DEPARTMENT
SET BUDGET = BUDGET - 11000
WHERE DNUMBER = 14;
COMMIT WORK;

(T₆):BEGIN WORK;
-- T₆の更新処理１
UPDATE DEPARTMENT
SET BUDGET = BUDGET 15000
WHERE DNUMBER = 3 OR DNUMBER = 14;
-- T₆の更新処理２
UPDATE DEPARTMENT
SET MGRSSN = 433424659
WHERE DNUMBER = 22;
-- T₆の検索処理３
SELECT *
FROM DEPARTMENT
WHERE DNUMBER = 23;
COMMIT WORK;

(T₇):BEGIN WORK;
-- T₇の更新処理1
UPDATE EMPLOYEE
SET BDATE = 'DEC-27-1971'
WHERE SSN = 1645455566;
COMMIT WORK;

(T₈):BEGIN WORK;
-- T₈の更新処理１
UPDATE EMPLOYEE
SET DNUM = 7
WHERE PHONE = 21-3728 OR SSN = 2066567788;
COMMIT WORK;

[(1) トランザクションの部分処理の作成（S201）]
入力されたトランザクションT₁, T₂, T₃, T₄, T₅, T₆, T₇, T₈に対して、個々のトランザクションが行うレコードrの読み取り処理をread_item(r)として表わし、レコードrの書き込み処理をwrite_item(r)として表わし、個々のトランザクションの部分処理を作成すると次のようになる。リレーションDEPARTMENT内のレコードは、D.ri(i=1,2,3,…,25)で表わし、リレーションEMPLOYEE内のレコードは、E.ri(i=1,2,3,…,20)で表わし、個々のレコードの格納位置は、リレーションに存在するインデックスを用いて調べることにする。
各トランザクションに含まれる個々の更新処理、及び検索処理などの部分処理は、タスクt_i ^j(i=トランザクションの番号、j=トランザクション内の処理番号)として表わすことにする。

(T₁):
(t₁ ¹):read_item(D.r7);
D.r7.BUDGET := D.r7.BUDGET + 10000;
write_item(D.r7);
(t₁ ²):read_item(D.r9);
D.r9.BUDGET := D.r9.BUDGET + 20000;
write_item(D.r9);
(t₁ ³):read_item(E.r14);
E.r14.DNUM := 4;
write_item(E.r14);

(T₂):
(t₂ ¹):read_item(D.r7);
D.r7.BUDGET := D.r7.BUDGET + 22000;
write_item(D.r7);
(t₂ ²):read_item(D.r7);
D.r7.BUDGET := D.r7.BUDGET + 30000;
write_item(D.r7);
read_item(D.r8);
D.r8.BUDGET := D.r8.BUDGET + 30000;
write_item(D.r8);

(T₃):
(t₃ ¹):read_item(D.r6);
D.r6.MGRSSN := 470124116;
write_item(D.r6);
read_item(D.r19);
D.r19.MGRSSN := 470124116;
write_item(D.r19);
(t₃ ²):read_item(D.r19);

(T₄):
(t₄ ¹):read_item(D.r3);
D.r3.DPHONE := 23-3736;
write_item(D.r3);
(t₄ ²):read_item(D.r19);
D.r19.DPHONE := 23-3737;
write_item(D.r19);
(t₄ ³):read_item(E.r10);
E.r10.BDATE := 'DEC-27-1971';
write_item(E.r10);

(T₅):
(t₅ ¹):read_item(D.r7);
D.r7.BUDGET := D.r7.BUDGET 24000;
write_item(D.r7);
read_item(D.r8);
D.r8.BUDGET := D.r8.BUDGET 24000;
write_item(D.r8);
(t₅ ²):read_item(D.r14);
D.r14.BUDGET := D.r14.BUDGET 11000;
write_item(D.r14);

(T₆):
(t₆ ¹):read_item(D.r3);
D.r3.BUDGET := D.r3.BUDGET 15000;
write_item(D.r3);
read_item(D.r14);
D.r14.BUDGET := D.r14.BUDGET 15000;
write_item(D.r14);
(t₆ ²):read_item(D.r22);
D.r22.MGRSSN := 433424659;
write_item(D.r22);
(t₆ ³):read_item(D.r23);

(T₇):
(t₇ ¹):read_item(E.r6);
E.r6.BDATE := 'DEC-27-1971';
write_item(E.r6);

(T₈):
(t₈ ¹):read_item(E.r6);
E.r6.DNUM := 7;
write_item(E.r6);
read_item(E.r10);
E.r10.DNUM := 7;
write_item(E.r10);

[(3) トランザクションの実行順の決定（S202）]
トランザクションの部分処理を求めると、トランザクションT₁, T₂, T₃, T₄, T₅, T₆, T₇, T₈に対して、トランザクションの実行順を決定することになる。
トランザクションの実行順を決定するには、トランザクションに含まれる部分処理をもとにしてトランザクションの処理コストを求め、トランザクションの処理コストの小さい順にトランザクションを並べてトランザクションの実行順を決定するとよい。そのため、トランザクションの部分処理をもとにしてトランザクションの処理コストをもとめると次のようになる。

トランザクションの処理コストは、トランザクションの処理に必要とされるブロックのアクセス回数である。例えば、トランザクションT₁はリレーションDEPARTMENTのブロックb₂に格納してあるレコードr7とr9と、リレーションEMPLOYEEのブロックb₄に格納してあるレコードr14と、２つのブロックをアクセスする必要があるので、処理コストを２とする。
トランザクションの処理コストを求めると、次のようにして処理コストの小さい順にトランザクションを並べてトランザクションの実行順をT₂, T₇, T₃, T₁, T₅, T₈, T₄, T₆と決定することができる。ここで、sortは処理コストの小さい順に並べ換えることを表わしている。
sort(T₁, T₂, T₃, T₄, T₅, T₆, T₇, T₈)⇒ (T₂, T₇, T₁, T₃, T₅, T₈, T₄, T₆)

[(4) 先行グラフの作成（S203)]
トランザクションの実行順を決定すると、トランザクションT₂, T₇, T₁, T₃, T₅, T₈, T₄, T₆を接点とした図４（ａ）に示す先行グラフを作成する。先行グラフを作成するにあたって、トランザクションT₂, T₇, T₃, T₁, T₅, T₈, T₄, T₆の中で複数のトランザクションが同一のデータ項目に対して処理を行う場合、そのデータ項目に対して矢印を持った枝を作成し、トランザクションの実行順に先に処理を行うトランザクションの接点から次に処理を行うトランザクションの接点へとその枝を入力させて、同一のデータ項目に対するトランザクションの実行順を示しておく。なお、１つのトランザクションだけで処理されるデータ項目は先行グラフに枝を記入しないことにする。

トランザクションT₄, T₆は、リレーションDEPARTMENT内の同一のレコードD.r3に対して更新処理を行うため、トランザクションの実行順に、接点T₄から接点T₆へと枝を入力させる。
トランザクションT₂,T₁,T₅は、リレーションDEPARTMENT内の同一のレコードD.r7に対して更新処理を行うため、トランザクションの実行順に、接点T₂から接点T₁へと枝を入力させ、接点T₁から接点T₅へと枝を入力させる。
トランザクションT₂,T₅は、リレーションDEPARTMENT内の同一のレコードD.r8に対して更新処理を行うため、トランザクションの実行順に、接点T₂から接点T₅へと枝を入力させる。
トランザクションT₅,T₆は、リレーションDEPARTMENT内の同一のレコードD.r14に対して更新処理を行うため、トランザクションの実行順に、接点T₅から接点T₆へと枝を入力させる。

トランザクションT₃,T₄は、リレーションDEPARTMENT内の同一のレコードD.r19に対して更新処理を行うため、トランザクションの実行順に、接点T₃から接点T₄へと枝を入力させる。
トランザクションT₇,T₈は、リレーションEMPLOYEE内の同一のレコードE.r6に対して更新処理を行うため、トランザクションの実行順に、接点T₇から接点T₈へと枝を入力させる。
トランザクションT₈,T₄は、リレーションEMPLOYEE内の同一のレコードE.r10に対して更新処理を行うため、トランザクションの実行順に、接点T₈から接点T₄へと枝を入力させる。
なお、図４（ａ）に示す先行グラフは、トランザクションの実行順にもとづいて作成されるため、サイクルを含んでおらず、この先行グラフをもとにして行われるトランザクションのスケジュールは、直列可能スケジュールである。

[(5) タスクのグループ化（Ｓ204)]
トランザクションT₂, T₇, T₁, T₃, T₅, T₈, T₄, T₆から、トランザクションの部分処理であるタスクt₂ ¹,t₂ ²,t₇ ¹,t₁ ¹,t₁ ²,t₁ ³,t₃ ¹,t₃ ²,t₅ ¹,t₅ ²,t₈ ¹,t₄ ¹,t₄ ²,t₄ ³,t₆ ¹,t₆ ²,t₆ ³を取り出し、取り出したタスクをデータベースのリレーションをもとにしてグループに分け、グループ分けされたタスクをトランザクションの実行順に並べると次のようになる。
DEPARTMENT: グループ G1 = {t₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₃ ², t₅ ¹, t₅ ², t₄ ¹, t₄ ², t₆ ¹, t₆ ², t₆ ³}
EMPLOYEE: グループ G2 = {t₇ ¹, t₁ ³, t₈ ¹, t₄ ³}
グループG1にはリレーションDEPARTMENTに対して処理を行うタスクを集め、グループG2にはリレーションEMPLOYEEに対して処理を行うタスクを集めることになる。

[(6) 合成トランザクションT_G1,G2の作成(S205)及び処理(S206)]
タスクをグループ分けして、グループG1,G2を作成すると、グループG1,G2を用いて合成トランザクションT_G1,G2を作成する。合成トランザクションT_G1,G2の処理を行うには、合成トランザクションT_G1,G2に含まれるグループG1, G2に対して、それぞれマルチオペレーション・プロセッシングを用いて処理することになる。

[(6-1) グループG1の処理]
[(a) タスクがアクセスするブロックの集合(S207)]
図３のリレーションDEPARTMENT(300)の主インデックス(310)及び二次インデックス(321,322)を用いて、グループG1内のタスクt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₃ ², t₅ ¹, t₅ ², t₄ ¹, t₄ ², t₆ ¹, t₆ ², t₆ ³を処理するために読み出す必要のあるリレーションDEPARTMENT(300)内のブロックを調べて、個々のタスクに対応するブロック集合B₂ ¹, B₂ ², B₁ ¹, B₁ ², B₃ ¹, B₃ ², B₅ ¹, B₅ ², B₄ ¹, B₄ ², B₆ ¹, B₆ ², B₆ ³に集めると次のようになる。ここでブロック集合を見出すにあたっては、インデックスによるブロックの格納位置を調べるだけであって、リレーション内のブロックをディスクにアクセスしてブロックの格納位置を調べることではない。

タスクt₂ ¹に対して、B₂ ¹ = {b₂}
タスクt₂ ²に対して、B₂ ² = {b₂}
タスクt₁ ¹に対して、B₁ ¹ = {b₂}
タスクt₁ ²に対して、B₁ ² = {b₂}
タスクt₃ ¹に対して、B₃ ¹ = {b₂,b₄}
タスクt₃ ²に対して、B₃ ² = {b₄}
タスクt₅ ¹に対して、B₅ ¹ = {b₂}
タスクt₅ ²に対して、B₅ ² = {b₃}
タスクt₄ ¹に対して、B₄ ¹ = {b₁}
タスクt₄ ²に対して、B₄ ² = {b₄}
タスクt₆ ¹に対して、B₆ ¹ = {b₁,b₃}
タスクt₆ ²に対して、B₆ ² = {b₅}
タスクt₆ ³に対して、B₆ ³ = {b₅}

[(b) ブロックのアクセス順位の決定（Ｓ208)]
グループ内の個々のタスクに対応するブロック集合を見出すと、グループにタスクが並べられた順に、すなわちt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₃ ², t₅ ¹, t₅ ², t₄ ¹, t₄ ², t₆ ¹, t₆ ², t₆ ³の順に、各タスクに対応するブロック集合の和集合を求めていく。最初に、TB₀={}(空集合)を用意し、TB₀とタスクt₂ ¹に対応するブロック集合B₂ ¹との和集合TB₂ ¹を求める。次に、このTB₂ ¹とタスクt₂ ²に対応するブロック集合B₂ ²との和集合TB₂ ²を求める。同様にして、タスクt₁ ¹, t₁ ², t₃ ¹, t₃ ², t₅ ¹, t₅ ², t₄ ¹, t₄ ², t₆ ¹, t₆ ², t₆ ³に対応するブロック集合B₁ ¹, B₁ ², B₃ ¹, B₃ ², B₅ ¹, B₅ ², B₄ ¹, B₄ ², B₆ ¹, B₆ ², B₆ ³に対しても和集合TB₁ ¹, TB₁ ², TB₃ ¹, TB₃ ², TB₅ ¹, TB₅ ², TB₄ ¹, TB₄ ², TB₆ ¹, TB₆ ², TB₆ ³を順次求めると次のようになる。この場合、順次和集合に加わるブロックは和集合中のブロックの後に加えていくものとする。

TB₀ ← ｛｝(空集合)
ブロック集合B₂ ¹との和集合: TB₂ ¹ ← TB₀ U B₂ ¹, TB₂ ¹ = {b₂}
ブロック集合B₂ ²との和集合: TB₂ ² ← TB₂ ¹ U B₂ ², TB₂ ² = {b₂}
ブロック集合B₁ ¹との和集合: TB₁ ¹ ← TB₂ ² U B₁ ¹, TB₁ ¹ = {b₂}
ブロック集合B₁ ²との和集合: TB₁ ² ← TB₁ ¹ U B₁ ², TB₁ ² = {b₂}
ブロック集合B₃ ¹との和集合: TB₃ ¹ ← TB₁ ² U B₃ ¹, TB₃ ¹ = {b₂, b₄}
ブロック集合B₃ ²との和集合: TB₃ ² ← TB₃ ¹ U B₃ ², TB₃ ² = {b₂, b₄}
ブロック集合B₅ ¹との和集合: TB₅ ¹ ← TB₃ ² U B₅ ¹, TB₅ ¹ = {b₂, b₄}
ブロック集合B₅ ²との和集合: TB₅ ² ← TB₅ ¹ U B₅ ², TB₅ ² = {b₂, b₄, b₃}
ブロック集合B₄ ¹との和集合: TB₄ ¹ ← TB₅ ² U B₄ ¹, TB₄ ¹ = {b₂, b₄, b₃, b₁}
ブロック集合B₄ ²との和集合: TB₄ ² ← TB₄ ¹ U B₄ ², TB₄ ² = {b₂, b₄, b₃, b₁}
ブロック集合B₆ ¹との和集合: TB₆ ¹ ← TB₄ ² U B₆ ¹, TB₆ ¹ = {b₂, b₄, b₃, b₁}
ブロック集合B₆ ²との和集合: TB₆ ² ← TB₆ ¹ U B₆ ², TB₆ ² = {b₂, b₄, b₃, b₁, b₅}
ブロック集合B₆ ³との和集合: TB₆ ³ ← TB₆ ² U B₆ ³, TB₆ ³ = {b₂, b₄, b₃, b₁, b₅}

以上のように、各タスクに対応するブロック集合に対して、タスクが並べられた順に、順次和集合を求めていくと、最後の和集合TB₆ ³から、ブロックb₂からブロックのアクセスを開始し、ブロックb₅でアクセスを終了すればよいことになり、リレーションDEPARTMENT(300)内のブロックへのアクセス順は(b₂, b₄, b₃, b₁, b₅)となる。このような手法で和集合を求めることによって、リレーションDEPARTMENT(300)内のブロックへのアクセス順を決定することができ、この順にブロックを読み出し、読み出したブロックにアクセスするタスクをグループ内から抽出して実行していくことになる。

[(c) 各ブロックでのタスク処理(S209)]
[(c-1) ブロックb₂にアクセス]
最初に、リレーションDEAPARTMENT内のブロックの格納位置が256であるブロックb₂内のデータをディスクからメインメモリに読み込み、グループG1内のタスクt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₃ ², t₅ ¹, t₅ ², t₄ ¹, t₄ ², t₆ ¹, t₆ ², t₆ ³がブロックb₂で処理を行う必要があるかどうかを調べるため、ブロックb₂を集合{b₂}として表し、{b₂}とブロック集合B₂ ¹,B₂ ², B₁ ¹, B₁ ², B₃ ¹, B₃ ², B₅ ¹, B₅ ², B₄ ¹, B₄ ², B₆ ¹, B₆ ², B₆ ³との間でそれぞれ積集合(∩) を求めると次のようになる。

タスクt₂ ¹に対して: B₂ ¹ ∩ {b₂} = {b₂}
タスクt₂ ²に対して: B₂ ² ∩ {b₂} = {b₂}
タスクt₁ ¹に対して: B₁ ¹ ∩ {b₂} = {b₂}
タスクt₁ ²に対して: B₁ ² ∩ {b₂} = {b₂}
タスクt₃ ¹に対して: B₃ ¹ ∩ {b₂} = {b₂}
タスクt₃ ²に対して: B₃ ² ∩ {b₂} = {}
タスクt₅ ¹に対して: B₅ ¹ ∩ {b₂} = {b₂}
タスクt₅ ²に対して: B₅ ² ∩ {b₂} = {}
タスクt₄ ¹に対して: B₄ ¹ ∩ {b₂} = {}
タスクt₄ ²に対して: B₄ ² ∩ {b₂} = {}
タスクt₆ ¹に対して: B₆ ¹ ∩ {b₂} = {}
タスクt₆ ²に対して: B₆ ² ∩ {b₂} = {}
タスクt₆ ³に対して: B₆ ³ ∩ {b₂} = {}

タスクt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₅ ¹に対して積集合が{b₂}となり、ブロックb₂で処理が可能となり、メインメモリに読み込んだブロックb₂でタスクt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₅ ¹の処理を行っていく。
タスクt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₅ ¹の処理を行うにあたっては、ブロック内のレコード順位が小さいレコードから順番に処理していき、個々のレコードに対しては、タスクt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₅ ¹の順番でタスク処理を行っていくことになり、それらの処理は次のような順番になる。

レコードD.r6に関しては、タスクt₃ ¹がレコードD.r6に対して更新処理を行う。
レコードD.r7に関しては、図４（ａ）に示す先行グラフに示すトランザクションのT₂,T₁,T₅の実行順に、それらのトランザクションの部分処理であるタスクt₂ ¹, t₂ ², t₁ ¹, t₅ ¹の更新処理を順次行っていく。タスクt₂ ¹は、データベースから読み込んだレコードD.r7に対して更新処理を行う。タスクt₂ ²は、タスクt₂ ¹が更新したレコードD.r7に対して更新処理を行う。タスクt₁ ¹は、タスクt₂ ²が更新したレコードD.r7に対して更新処理を行う。タスクt₅ ¹は、タスクt₁ ¹が更新したレコードD.r7に対して更新処理を行う。このようにタスクt₂ ¹,t₂ ²,t₁ ¹,t₅ ¹による更新処理をメインメモリ内で順次行い、タスクt₅ ¹による最後の更新結果のみをデータベースに一度だけ書き込むことになる。
レコードD.r8に関しては、先行グラフ400に示すトランザクションのT₂,T₅の実行順に、それらのトランザクションの部分処理であるタスクt₂ ², t₅ ¹の更新処理を順次行っていく。タスクt₂ ²は、データベースから読み込んだレコードD.r8に対して更新処理を行う。タスクt₅ ¹は、タスクt₂ ²が更新したレコードD.r8に対して更新処理を行う。タスクt₂ ², t₅ ¹による更新処理はメインメモリ内で順次行い、タスクt₅ ¹による最後の更新結果のみをデータベースに一度だけ書き込むことになる。

レコードD.r9に関しては、タスクt₁ ²がレコードD.r9に対して更新処理を行う。
ブロックb₂でのタスクt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₅ ¹の処理が終了すると、ブロックb₂を再びアクセスする必要がなくなるので、ブロック集合B₂ ¹, B₂ ², B₁ ¹, B₁ ², B₃ ¹, B₅ ¹と集合{b₂}との差集合を求めて、得られた差集合をB₂ ¹⁽¹⁾, B₂ ²⁽¹⁾, B₁ ¹⁽¹⁾, B₁ ²⁽¹⁾, B₃ ¹⁽¹⁾, B₅ ¹⁽¹⁾とすると、次のようになる。
タスクt₂ ¹に対して: B₂ ¹⁽¹⁾ ← B₂ ¹ - {b₂}, B₂ ¹⁽¹⁾ = {}
タスクt₂ ²に対して: B₂ ²⁽¹⁾ ← B₂ ² - {b₂}, B₂ ²⁽¹⁾ = {}
タスクt₁ ¹に対して: B₁ ¹⁽¹⁾ ← B₁ ¹ - {b₂}, B₁ ¹⁽¹⁾ = {}
タスクt₁ ²に対して: B₁ ²⁽¹⁾ ← B₁ ² - {b₂}, B₁ ²⁽¹⁾ = {}
タスクt₃ ¹に対して: B₃ ¹⁽¹⁾ ← B₃ ¹ - {b₂}, B₃ ¹⁽¹⁾ = {b₄}
タスクt₅ ¹に対して: B₅ ¹⁽¹⁾ ← B₅ ¹ - {b₂}, B₅ ¹⁽¹⁾ = {}

この結果、ブロック集合B₂ ¹⁽¹⁾, B₂ ²⁽¹⁾, B₁ ¹⁽¹⁾, B₁ ²⁽¹⁾, B₅ ^{1 (1)} が空集合({})になり、タスクt₂ ¹, t₂ ², t₁ ¹, t₁ ²,t₅ ¹の処理が終了する。すると、トランザクションT₂内のすべてのタスクの処理が終了するので、この時点でトランザクションT₂をコミットできるかどうかを、図４（ａ）の先行グラフをもとにして決定する。接点T₂には、他のどの接点からも入力している枝がないので、トランザクションT₂をコミットすることになる。T₂をコミットすると、図４（ａ）の先行グラフから接点T₂と接点T₂から出力しているすべての枝を削除し、その結果を図４（ｂ）の先行グラフとして表わすことができる。
また、トランザクションT₁,T₅によるレコードD.r7に対する更新処理は終了したけれども、T₁,T₅はまだコミットしていないため、図４（ｂ）の先行グラフ内の接点T₁から接点T₅へと入力しているD.r7の枝を点線の枝として残しておくことにする。

[(c-2) ブロックb₄にアクセス]
次に、リレーションDEPARTMENT内のブロックの格納位置が768であるブロックb₄内のデータをディスクからメインメモリに読み込み、すでに処理が終了したタスクt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₅ ¹以外のグループ内のタスクt₃ ¹, t₃ ², t₅ ², t₄ ¹, t₄ ², t₆ ¹, t₆ ², t₆ ³がブロックb₄で処理を行う必要があるかどうかを調べるため、ブロックb₄を集合{b₄}として表し、{b₄}とブロック集合B₃ ¹⁽¹⁾, B₃ ², B₅ ², B₄ ¹, B₄ ², B₆ ¹, B₆ ², B₆ ³との間でそれぞれ積集合(∩)を求めると次のようになる。

タスクt₃ ¹に対して: B₃ ¹⁽¹⁾ ∩ {b₄} = {b₄}
タスクt₃ ²に対して: B₃ ² ∩ {b₄} = {b₄}
タスクt₅ ²に対して: B₅ ² ∩ {b₄} = {}
タスクt₄ ¹に対して: B₄ ¹ ∩ {b₄} = {}
タスクt₄ ²に対して: B₄ ² ∩ {b₄} = {b₄}
タスクt₆ ¹に対して: B₆ ¹ ∩ {b₄} = {}
タスクt₆ ²に対して: B₆ ² ∩ {b₄} = {}
タスクt₆ ³に対して: B₆ ³ ∩ {b₄} = {}

タスクt₃ ¹, t₃ ², t₄ ²に対して積集合が{b₄}となり、ブロックb₄で処理が可能となり、メインメモリに読み込んだブロックb₄でタスクt₃ ¹, t₃ ², t₄ ²の処理を行うと次のようになる。

レコードD.r19に関しては、図４（ｂ）の先行グラフに示すトランザクションT₃, T₄の実行順に、それらのトランザクションの部分処理であるタスクt₃ ¹, t₄ ²の更新処理を順次行っていく。

タスクt₃ ¹は、データベースから読み込んだレコードD.r19に対して更新処理を行い、タスクt₄ ²は、タスクt₃ ¹が更新したレコードD.r19に対して更新処理を行うことになる。このようにタスクt₃ ¹, t₄ ²による更新処理をメインメモリ内で順次行い、タスクt₄ ²による最後の更新結果のみをデータベースに一度だけ書き込むことになる。
タスクt₃ ²の検索処理は、レコードD.r19を検索することである。そのためメインメモリに読み込まれたレコードD.r19に対して、タスクt₃ ²と同じトランザクションT₃に含まれるタスクt₃ ¹の更新処理が先に行われると、タスクt₄ ²の更新処理が行われる前に、タスクt₃ ¹によるレコードD.r19の更新結果を、タスクt₃ ²の検索結果として取り出すことになる。

ブロックb₄でのタスクt₃ ¹, t₃ ², t₄ ²の処理が終了すると、ブロックb₄を再びアクセスする必要がなくなるので、集合B₃ ¹⁽¹⁾, B₃ ², B₄ ²と集合{b₄}との差集合を求めて、得られた差集合をB₃ ¹⁽²⁾, B₃ ²⁽¹⁾, B₄ ²⁽¹⁾とすると、次のようになる。
タスクt₃ ¹に対して: B₃ ¹⁽²⁾ ← B₃ ¹⁽¹⁾ - {b₄}, B₃ ¹⁽²⁾ = {}
タスクt₃ ²に対して: B₃ ²⁽¹⁾ ← B₃ ² - {b₄}, B₃ ²⁽¹⁾ = {}
タスクt₄ ²に対して: B₄ ²⁽¹⁾ ← B₄ ² - {b₄}, B₄ ²⁽¹⁾ = {}
この結果、ブロック集合B₃ ¹⁽²⁾, B₃ ²⁽¹⁾, B₄ ²⁽¹⁾が空集合({})になり、タスクt₃ ¹, t₃ ², t₄ ²の処理が終了し、トランザクションT₃に含まれるすべてのタスクの処理が終了することになり、トランザクションT₃が終了すると、この時点でトランザクションT₃をコミットできるかどうかを、図４（ｂ）の先行グラフをもとにして決定する。接点T₃には、他のどの接点からも入力枝がないので、トランザクションT₃をコミットする。T₃をコミットすると、接点T₃と接点T₃から出力している枝を図４（ｂ）の先行グラフから削除し、その結果を図４（ｃ）の先行グラフとして表わすことができる。

[(c-3) ブロックb₃の読み込み]
次に、リレーションDEPARTMENT内のブロックの格納位置が512であるブロックb₃内のデータをディスクからメインメモリに読み込み、すでに処理が終了したタスクt₂ ¹, t₂ ², t₁ ¹, t₁ ²,t₃ ¹,t₃ ², t₅ ¹, t₄ ² 以外のグループ内のタスクt₅ ², t₄ ¹, t₆ ¹, t₆ ², t₆ ³がブロックb₃で処理を行う必要があるかどうかを調べるため、ブロックb₃を集合{b₃}として表し、この{b₃}とブロック集合B₅ ², B₄ ¹, B₆ ¹, B₆ ², B₆ ³との間でそれぞれ積集合(∩) を求めると次のようになる。

タスクt₅ ²に対して: B₅ ² ∩ {b₃} = {b₃}
タスクt₄ ¹に対して: B₄ ¹ ∩ {b₃} = {}
タスクt₆ ¹に対して: B₆ ¹ ∩ {b₃} = {b₃}
タスクt₆ ²に対して: B₆ ² ∩ {b₃} = {}
タスクt₆ ³に対して: B₆ ³ ∩ {b₃} = {}

タスクt₅ ², t₆ ¹に対して積集合が{b₃}となり、ブロックb₃で処理が可能となり、メインメモリに読み込んだブロックb₃でタスクt₅ ², t₆ ¹の処理を行うと次のようになる。

レコードD.r14に関しては、図４（ｃ）の先行グラフに示すトランザクションT₅, T₆の実行順に、それらのトランザクションの部分処理であるタスクt₅ ², t₆ ¹の更新処理を順次行っていく。
タスクt₅ ²は、データベースから読み込んだレコードD.r14に対して更新処理を行い、タスクt₆ ¹は、タスクt₅ ²が更新したレコードD.r14に対して更新処理を行うことになる。このようにタスクt₅ ²,t₆ ¹による更新処理をメインメモリ内で順次行い、タスクt₆ ¹による最後の更新結果のみをデータベースに一度だけ書き込むことになる。
ブロックb₃でのタスク t₅ ²,t₆ ¹の処理が終了すると、ブロックb₃を再びアクセスする必要がなくなるので、ブロック集合 B₅ ², B₆ ¹と集合{b₃}との差集合を求めて、得られた差集合をB₅ ²⁽¹⁾,B₆ ¹⁽¹⁾とすると、次のようになる。
タスクt₅ ²に対して: B₅ ²⁽¹⁾ ← B₅ ² - {b₃}, B₅ ²⁽¹⁾ = {}
タスクt₆ ¹に対して: B₆ ¹⁽¹⁾ ← B₆ ¹ - {b₃}, B₆ ¹⁽¹⁾ = {b₁}
この結果、ブロック集合B₅ ²⁽¹⁾が空集合({})になり、タスクt₅ ²の処理が終了する。

タスクt₅ ²の処理が終了すると、トランザクションT₅に含まれるすべてのタスクの処理が終了することになり、この時点でトランザクションT₅をコミットできるかどうかを、図４（ｃ）の先行グラフをもとにして決定する。トランザクションT₅は、トランザクションT₁が先に処理を行ったレコードD.r7に対して処理を行っていて、トランザクションT₁はまだコミットしていないため、トランザクションT₅をコミットすることはできない。そのためT₅をコミット待ちのトランザクションとして置いておくことになる。図４（ｄ）の先行グラフは、トランザクションT₅の処理は終了したけれども、コミットできない状態を点線の接点T₅として表わしている。
また、トランザクションT₅,T₆によるレコードD.r14に対する更新処理は終了したけれども、T₅,T₆はまだコミットしていないため、図４（ｄ）の先行グラフ内の接点T₅から接点T₆へと入力しているD.r14の枝を点線の枝として残しておくことにする。

[(c-4) ブロックb₁にアクセス]
次に、リレーションDEPARTMENT内のブロックの格納位置が0であるブロックb₁内のデータをディスクからメインメモリに読み込み、すでに処理が終了したタスクt₂ ¹, t₂ ², t₁ ¹, t₁ ²,t₃ ¹,t₃ ², t₅ ¹, t₅ ²,t₄ ²以外のグループ内のタスクt₄ ¹, t₆ ¹, t₆ ², t₆ ³ がブロックb₁で処理を行う必要があるかどうかを調べるため、ブロックb₁を集合{b₁}として表し、この{b₁}とブロック集合B₄ ¹, B₆ ¹⁽¹⁾, B₆ ², B₆ ³との間でそれぞれ積集合(∩) を求めると次のようになる。
タスクt₄ ¹に対して: B₄ ¹ ∩ {b₁} = {b₁}
タスクt₆ ¹に対して: B₆ ¹⁽¹⁾ ∩ {b₁} = {b₁}
タスクt₆ ²に対して: B₆ ² ∩ {b₁} = {}
タスクt₆ ³に対して: B₆ ³ ∩ {b₁} = {}

タスクt₄ ¹, t₆ ¹に対して積集合が{b₁}となり、ブロックb₁で処理が可能となり、メインメモリに読み込んだブロックb₁でタスクt₄ ¹, t₆ ¹の処理を行うと次のようになる。

レコードD.r3に関しては、図４（ｄ）の先行グラフに示すように、トランザクションT₄,T₆の実行順に、それらのトランザクションの部分処理であるタスクt₄ ¹,t₆ ¹の更新処理を順次行っていく。タスクt₄ ¹は、データベースから読み込んだレコードD.r3に対して更新処理を行い、タスクt₆ ¹は、タスクt₄ ¹が更新したレコードD.r3に対して更新処理を行うことになる。このようにタスクt₄ ¹,t₆ ¹による更新処理をメインメモリ内で順次行い、タスクt₆ ¹による最後の更新結果のみをデータベースに一度だけ書き込むことになる。

ブロックb₁でのタスクt₄ ¹,t₆ ¹の処理が終了すると、ブロックb₁を再びアクセスする必要がなくなるので、ブロック集合B₄ ¹, B₆ ¹⁽¹⁾と集合{b₁}との差集合を求めて、得られた差集合をB₄ ¹⁽¹⁾, B₆ ¹⁽²⁾とすると、次のようになる。
t₄ ¹に対して: B₄ ¹⁽¹⁾ ← B₄ ¹ - {b₁}, B₄ ¹⁽¹⁾ = {}
t₆ ¹に対して: B₆ ¹⁽²⁾ ← B₆ ¹⁽¹⁾ - {b₁}, B₆ ¹⁽²⁾ = {}
この結果、ブロック集合B₄ ¹⁽¹⁾,B₆ ¹⁽²⁾が空集合({})になり、タスクt₄ ¹, t₆ ¹の処理が終了する。図４（ｅ）の先行グラフは、トランザクションT₄,T₆によるレコードD.r3に対する更新処理が終了したけれども、トランザクションT₄,T₆の処理がまだ終了していないので、接点T₄から接点T₆へと入力しているD.r3の枝を点線の枝として残していることを表わしている。

[(c-5) ブロックb₅の読み込み]
最後に、リレーションDEPARTMENT内のブロックの格納位置が1024であるブロックb₅内のデータをディスクからメインメモリに読み込み、ブロックb₅でグループG1内の最後のタスクt₆ ²,t₆ ³の処理を行うと次のようになる。

タスクt₆ ²は、データベースから読み込んだレコードD.r22に対して更新処理を行う。
タスクt₆ ³は、データベースから読み込んだレコードD.r23を取り出して検索することになる。

タスクt₆ ², t₆ ³の処理が終了すると、トランザクションT₆内のすべてのタスクの処理が終了するので、この時点でトランザクションT₆をコミットできるかどうかを、図４（ｅ）の先行グラフをもとにして決定する。トランザクションT₆は、トランザクションT₅が先に処理を行ったレコードD.r14に対して処理を行い、トランザクションT₄が先に処理を行ったレコードD.r3に対して処理を行っているが、トランザクションT₅,T₄はまだコミットしていないので、トランザクションT₆をコミットすることはできない。したがって、トランザクションT₆はコミット待ちのトランザクションとして置いておくことになる。図４（f）の先行グラフは、トランザクションT₆の処理は終了したけれども、コミットできない状態を点線の接点T₆として表わしている。
タスクt₆ ², t₆ ³の処理が終了すると、グループG1内のすべてのタスクの処理が終了することになる。グループG1の処理が終了すると、合成トランザクションに含まれるグループG2の処理を開始することになる。

[(6-2) グループG2の処理]
リレーションEMPLOYEEに対するグループG2の処理は、グループG1の処理と同様に、グループG2内のタスクに対してマルチオペレーション・プロセッシングを用いて処理することになる。

[(a) タスクがアクセスするブロックの集合]
図３−２のリレーションEMPLOYEE(400)の主インデックス（410)及び二次インデックス(420)を用いて、グループG2内のタスクt₇ ¹, t₁ ³, t₈ ¹, t₄ ³を処理するために読み出す必要のあるリレーションEMPLOYEE内のすべてのブロックを調べて、個々のタスクに対応するブロック集合B₇ ¹, B₁ ³,B₈ ¹, B₄ ³に集めると次のようになる。
タスクt₇ ¹に対して、B₇ ¹ = {b₂}
タスクt₁ ³に対して、B₁ ³ = {b₄}
タスクt₈ ¹に対して、B₈ ¹ = {b₂, b₃}
タスクt₄ ³に対して、B₄ ³ = {b₃}

[(b) ブロックのアクセス順位の決定]
ブロック集合を見出すと、グループ内のタスクが並べられた順に、すなわちt₇ ¹, t₁ ³, t₈ ¹, t₄ ³の順番で各タスク対応するブロック集合の和集合を求めていくと次のようになる。
TB₀ ← {} (空集合)
ブロック集合B₇ ¹との和集合: TB₇ ¹ ← TB₀ U B₇ ¹, TB₇ ¹ = {b₂}
ブロック集合B₁ ³との和集合: TB₁ ³ ← TB₇ ¹ U B₁ ³, TB₁ ³ = {b₂, b₄}
ブロック集合B₈ ¹との和集合: TB₈ ¹ ← TB₁ ³ U B₈ ¹, TB₈ ¹ = {b₂, b₄, b₃}
ブロック集合B₄ ³との和集合: TB₄ ³ ← TB₈ ¹ U B₄ ³, TB₄ ³ = {b₂, b₄, b₃}
以上のようにして順次和集合を求めていくと、最後の和集合TB₄ ³から、リレーションEMPLOYEEに対して、ブロックb₂からブロックのアクセスを開始し、ブロックb₃でアクセスを終了すればよいことになり、ブロックのアクセス順は(b₂, b₄, b₃)となる。

[(c) 各ブロックでのタスク処理]
[(c-1) ブロックb₂にアクセス]
最初に、リレーションEMPLOYEE(400)内のブロックの格納位置が256であるブロックb₂内のデータをディスクからメインメモリに読み込み、グループ内のタスクt₇ ¹, t₁ ³, t₈ ¹, t₄ ³がブロックb₂で処理を行う必要があるかどうかを調べるため、ブロックb₂を集合{b₂}として表し、{b₂}とブロック集合B₇ ¹, B₁ ³, B₈ ¹, B₄ ³との間でそれぞれ積集合(∩) を求めると次のようになる。
タスクt₇ ¹に対して: B₇ ¹ ∩ {b₂} = {b₂}
タスクt₁ ³に対して: B₁ ³ ∩ {b₂} = {}
タスクt₈ ¹に対して: B₈ ¹ ∩ {b₂} = {b₂}
タスクt₄ ³に対して: B₄ ³ ∩ {b₂} = {}

タスクt₇ ¹, t₈ ¹に対して積集合が{b₂}となり、ブロックb₂で処理が可能となり、メインメモリに読み込んだブロックb₂でタスクt₇ ¹, t₈ ¹の処理を行うと次のようになる。

レコードE.r6に関しては、図４（f）の先行グラフに示すように、レコードE.r6に対して、トランザクションT₇,T₈の実行順に、それらのトランザクションの部分処理であるタスクt₇ ¹,t₈ ¹の更新処理を順次行っていく。タスクt₇ ¹は、データベースから読み込んだレコードE.r6に対して更新処理を行い、タスクt₈ ¹は、タスクt₇ ¹が更新したレコードE.r6に対して更新処理を行うことになる。このようにタスクt₇ ¹,t₈ ¹による更新処理をメインメモリ内で順次行い、タスクt₈ ¹による最後の更新結果のみをデータベースに一度だけ書き込むことになる。

ブロックb₂でのタスクt₇ ¹, t₈ ¹の処理が終了すると、ブロックb₂を再びアクセスする必要がなくなるので、ブロック集合B₇ ¹, B₈ ¹と集合{b₂}との差集合を求めて、得られた差集合をB₇ ¹⁽¹⁾, B₈ ¹⁽¹⁾とすると、次のようになる。
タスクt₇ ¹に対して: B₇ ¹⁽¹⁾ ← B₇ ¹ - {b₂}, B₇ ¹⁽¹⁾ = {}
タスクt₈ ¹に対して: B₈ ¹⁽¹⁾ ← B₈ ¹ - {b₂}, B₈ ¹⁽¹⁾ = {b₃}
この結果、ブロック集合B₇ ¹⁽¹⁾が空集合({})になり、タスクt₇ ¹の処理が終了する。タスクt₇ ¹の処理が終了するとトランザクションT₇内のすべてのタスクの処理が終了することになり、図４（f）の先行グラフをもとにして、この時点でトランザクションT₇をコミットすることができるかどうかを決定する。接点T₇には、他のどの接点からも入力枝がないので、トランザクションT₇をコミットする。T₇をコミットすると、図４（f）の先行グラフから接点T₇と接点T₇から出ているすべての枝を削除し、その結果を図４（g）の先行グラフとして表わすことができる。

[(c-2) ブロックb₄の読み込み]
次に、リレーションEMPLOYEE(400)内のブロックの格納位置が768であるブロックb₄内のデータをディスクからメインメモリに読み込み、すでに処理が終了したタスクt₇ ¹以外のグループ内のタスクt₈ ¹, t₁ ³, t₄ ³がブロックb₄で処理を行う必要があるかどうかを調べるため、ブロックb₄を集合{b₄}として表し、この{b₄}とブロック集合B₈ ¹⁽¹⁾, B₁ ³, B₄ ³との間でそれぞれ積集合(∩) を求めると次のようになる。
タスクt₈ ¹に対して: B₈ ¹⁽¹⁾ ∩ {b₄} = {}
タスクt₁ ³に対して: B₁ ³ ∩ {b₄} = {b₄}
タスクt₄ ³に対して: B₄ ³ ∩ {b₄} = {}
タスクt₁ ³に対して積集合が{b₄}となり、ブロックb₄で処理が可能となり、メインメモリに読み込んだブロックb₄でタスクt₁ ³の更新処理を行うと次のようになる。

ブロックb₄でのタスクt₁ ³の処理が終了すると、ブロックb₄を再びアクセスする必要がなくなるので、ブロック集合B₁ ³と集合{b₄}との差集合を求めて、得られた差集合をB₁ ³⁽¹⁾とすると、次のようになる。
タスクt₁ ³に対して: B₁ ³⁽¹⁾ ← B₁ ³ - {b₄}, B₁ ³⁽¹⁾ = {}
この結果、ブロック集合B₁ ³⁽¹⁾が空集合({})になり、タスクt₁ ³の処理が終了する。タスクt₁ ³の処理が終了すると、トランザクションT₁内のすべてのタスクの処理が終了するため、この時点でトランザクションT₁がコミットできるかどうかを、図４（g）の先行グラフをもとにして決定する。接点T₁には、他のどの接点からも入力枝がないので、トランザクションT₁をコミットする。トランザクションT₁をコミットすると、接点T₁と接点T₁から出力しているすべての枝も削除される。T₁が削除されると、接点T₁から接点T₅へと入力している枝が削除され、接点T₅の入力枝がすべてなくなるため、トランザクションT₅もコミットすることになる。トランザクションT₁, T₅がコミットした結果は、図４（h）の先行グラフとして表わすことができる。

[(c-3) ブロックb₃にアクセス]
最後に、リレーションEMPLOYEE内のブロックの格納位置が512であるブロックb₃内のデータをディスクからメインメモリに読み込み、ブロックb₃でグループG2内に残ったタスクt₈ ¹,t₄ ³の処理を行うと次のようになる。

レコードE.r10に関しては、図４（h）の先行グラフに示すように、レコードE.r10に対して、トランザクションT₈,T₄の実行順に、それらのトランザクションの部分処理であるタスクt₈ ¹,t₄ ³の更新処理を順次行っていく。タスクt₈ ¹は、データベースから読み込んだレコードE.r10に対して更新処理を行い、タスクt₄ ³は、タスクt₈ ¹が更新したレコードE.r10に対して更新処理を行うことになる。このようにタスクt₈ ¹,t₄ ³による更新処理はメインメモリ内で順次行い、タスクt₄ ³による最後の更新結果のみをデータベースに一度だけ書き込むことになる。

タスクt₈ ¹,t₄ ³の処理が終了すると、トランザクションT₈,T₄のすべてのタスクが終了し、この時点で入力枝のないトランザクションT₈をコミットすることができ、さらにトランザクションT₄もコミットすることができので、図４（h）の先行グラフから接点T₈, T₄を削除する。そうすると、接点T₄から接点T₆へと伸びる枝も削除され、接点T₆の入力枝がすべてなくなる（図４（i）参照）ため、トランザクションT₆もコミットすることになる。その結果、入力されたすべてのトランザクションがT₂, T₃, T₇, T₁, T₅, T₈, T₄, T₆の順番でコミットしたことになる。

以上のことをまとめると表１０のようになる。グループG1の処理を行うには、リレーションDEPARMENT(300)に対して、ブロックb₂でタスクt₂ ¹, t₂ ², t₁ ¹, t₁ ², t₃ ¹, t₅ ¹の処理を行ってトランザクションT₂の処理が終了してコミットし、ブロックb₄でタスクt₃ ¹, t₃ ², t₄ ²の処理を行ってトランザクションT₃の処理が終了してコミットし、ブロックb₃でタスクt₅ ², t₆ ¹の処理を行ってトランザクションT₅の処理が終了し、ブロックb₁ではタスクt₄ ¹,t₆ ¹の処理を行い、ブロックb₅でタスクt₆ ²,t₆ ³の処理を行ってトランザクションT₆の処理が終了する。
グループG2の処理を行うには、リレーションEMPLOYEE（400)に対して、ブロックb₂でタスクt₇ ¹, t₈ ¹の処理を行ってトランザクションT₇が終了してコミットし、ブロックb₄でタスクt₁ ³の処理を行ってトランザクションT₁が終了してトランザクションT₁,T₅がコミットし、ブロックb₃でタスクt₈ ¹, t₄ ³の処理を行ってトランザクションT₈,T₄の処理が終了してトランザクションT₈, T₄, T₆がコミットする。

このようにして、入力された複数のトランザクションの処理が同時に行われ、T₂, T₃, T₇, T₁, T₅, T₈, T₄, T₆の順にトランザクションが終了してコミットすることになる。トランザクションがコミットした順は、最初に決定したトランザクションの実行順と若干異なるけれども、どちらの順もサイクルを含んでいない図４（ａ）の先行グラフをトポロジカルソートして得ることができる順なので、この手法は、トランザクションの実行順と競合等価な直列可能スケジュールである。

以上のように、同時に処理することのできる複数のトランザクションに対して、トランザクションの実行順を決定し、決定した順にデータを更新することを示した先行グラフを作成し、トランザクションに含まれる部分処理をタスクとして取り出し、取り出したタスクを、トランザクションの実行順に、データベースのリレーションごとにグループ分けし、グループ分けして作成したグループを用いて合成トランザクションを作成し、合成トランザクションに含まれる個々のグループに対してマルチオペレーション・プロセッシングを用いて処理を行っていくのがトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングによるデータベースのトランザクション処理システムである。

上記の具体例では、複数のトランザクションによって処理されるレコードをデータ項目として扱って説明した。レコードをデータ項目として扱うと、数多くのレコードが処理される場合、個々のレコードの格納位置を調べて、膨大な先行グラフを作成することになる。そのため、レコードが格納してあるブロックの格納位置だけを調べて、ブロックをデータ項目として扱い、ブロックに対して先行グラフを作成してもよい。その場合、アクセスしたブロックが先行グラフに存在するときに、そのブロックに対して、グループ内のタスク処理を順次行っていくことになる。
また、上記の具体例では、readとwriteを基本とするトランザクションの更新処理を扱った。実際の更新処理には、データの挿入や削除も行われる。マルチオペレーション・プロセッシングを用いてデータの挿入を行うには、データを挿入するブロックの格納位置を調べて、そのブロックに十分なスペースがある場合は、ブロックのアクセス順にしたがってそのブロックをアクセスした際に、データを挿入することになる。また、マルチオペレーション・プロセッシングを用いてデータの削除を行うには、データを削除するブロックの格納位置を調べて、ブロックのアクセス順にしたがってそのブロックをアクセスした際に、データを削除することになる。

合成トランザクションに含まれる個々のグループの処理は、異なるリレーションに対して行われるため、それらのグループの処理を同時に行っても、グループ間で同一のデータ項目がアクセスされることはない。また、グループに集められたトランザクションの部分処理であるタスクの処理は、メインメモリに読み込まれたブロック内のデータ項目に対して、先行グラフに示したトランザクションの実行順に順次実行していくので、合成トランザクションに合成された個々のトランザクションの間でロックをかける必要はない。したがってトランザクションが待たされたり、トランザクションが中断されたりするといった問題は起こらない。

本発明のトランザクション同時実行制御を備えたマルチオペレーション・プロセッシングにおいては、数多くのトランザクションが入力されると、1.1節で述べた手順にしたがって合成トランザクションを作成し、合成トランザクションの処理を行っていくことができ、１つの合成トランザクションの処理が終了した段階で、新たに数多くのトランザクションが入力されると、同様な手順を用いて別の合成トランザクションを作成し、その合成トランザクションの処理を行っていくことができるので、合成トランザクションの処理を順次１つずつ実行していく場合には、ロックを用いる必要性はなくなる。また、デッドロックなどを発生することもなく、合成トランザクションに含まれる複数のグループの処理を同時に並行して実行していくことができる。

このような処理で複数のトランザクションの処理速度を十分に向上させることができるが、図１のオペレーティング・システムのプロセス(104) によるCPUとディスクの資源(105)を効率よく利用するには、複数の合成トランザクションを同時に処理したほうが、効率がいい場合があるので、第２章では複数の合成トランザクションの処理を同時に実行していくためのシステムを提案する。

[2. 複数の合成トランザクションの処理]
合成トランザクションの処理を行っている間に、新たに別のトランザクションがいくつか到着すると、到着した複数のトランザクションに対して合成トランザクションが作成され、現在処理が行われている合成トランザクションと一緒に処理が行われると、複数の合成トランザクションの間でデータの矛盾が起こる可能性が出てくる。
例えば、合成トランザクションT_G1,G2の処理を行っている間に、図１のトランザクション処理システム（100）に、新たにトランザクションT₉,T₁₀,T₁₁が到着すると、トランザクションT₉,T₁₀,T₁₁に対して合成トランザクションT_G3,G4,G5を作成したとする。マルチオペレーション・プロセッサ（102）は、現在プロセス１とプロセス２を用いて合成トランザクションT_G1,G2の処理を行っていたとすると、残ったプロセス３とプロセス４とプロセス５を用いて合成トランザクションT_G3,G4,G5の処理を行うことになる。合成トランザクションT_G1,G2と合成トランザクションT_G3,G4,G5が同一のデータ項目に対して処理を行う必要がある場合、同時にデータが更新されてデータの矛盾が起こる可能性が出てくる。
複数の合成トランザクションの処理が競合してデータの矛盾が起こるといった問題を解決するために、二相ロックを用いたマルチオペレーション・プロセッシングとタイムスタンプを用いたマルチオペレーション・プロセッシングを提案する。

<二相ロックを用いたマルチオペレーション・プロセッシング>
二相ロックを用いたマルチオペレーション・プロセッシングは、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングに、二相ロックを加えたものである。二相ロックを用いたマルチオペレーション・プロセッシングは、合成トランザクションが処理を行う個々のデータ項目に対してロックをかけて処理を行う手法である。ロックの操作は、ロックをかける操作だけからなる成長相とロックをはずす操作だけからなる縮退相と分離して行う。そのため一度ロックをはずした後に、再びロックをかけることはない。なお、ロックをかけるにあたって、検索処理しか行わないデータ項目に対しては、共有ロックをかけ、更新処理を行うデータ項目に対しては、専有ロックをかけることになる。複数の合成トランザクションの間でデータの矛盾が起こらないようにするには、個々の合成トランザクションは、二相ロックを用いたマルチオペレーション・プロセッシングを使用して処理を行うことになる。

二相ロックを用いたマルチオペレーション・プロセッシングが、従来の二相ロック・プロトコルと異なる点は、従来のように複数のトランザクションの間でロックをかけるのではなく、マルチオペレーション・プロセッシングの処理を行う複数の合成トランザクションの間でロックをかける点である。また、合成トランザクション自体がコミットするのではなく、合成トランザクションに含まれる個々のトランザクションが順次コミットしていくことである。
また、複数の合成トランザクションの間でデッドロックが生じた場合の対処は、従来のデッドロックの対処と異なる。複数の合成トランザクションの間でデッドロックが生じた場合、デッドロックの関係にある合成トランザクションの１つを中断することになり、中断する合成トランザクションは、合成トランザクションに含まれるトランザクションの中で、コミットしたトランザクションの数が最も少ない合成トランザクションを中断することになる。合成トランザクションの処理を中断するには、合成トランザクションに含まれるトランザクションの中で、すでにコミットしたトランザクションはそのままにしておき、まだコミットしていないトランザクションのみを中断してロールバックし、中断したトランザクションは、トランザクション処理システム(100)に再提出することになる。

<二相ロックを用いたマルチオペレーション・プロセッシングの具体例>
図５−１，図５−２は、二相ロックを用いたマルチオペレーション・プロセッシングを使用して２つの合成トランザクションT _G1,G2, T_G3,G4,G5の処理を同時に並行して実行しているものを表わしている。合成トランザクションT _G1,G2は1.2章の具体列で用いた合計２つのリレーションDEPARTMENT(300), EMPLOYEE(400)に対して処理を行う合成トランザクションであり、合成トランザクションT_G3,G4,G5は、図１のトランザクション処理システム(100)に新たに到着したトランザクションT₉,T₁₀,T₁₁から作成された合計３つのリレーションPROJECT,EMPLOYEE,DEPARTEMTに対して処理を行う合成トランザクションである。
図５−１，図５−２において、レコードrに対して共有ロックをかける操作をread_lock(r)として表わし、レコードrに対して専有ロックをかける操作をwrite_lock(r)として表わし、レコードrに対してロックをはずす操作をunlock(r)として表わしている。また、リレーションDEPARTMENT(300)内のレコードは、D.riとして表わし、リレーションEMPLOYEE(400)内のレコードはE.riとして表わし、リレーションPROJECT(図示せず)内のレコードはP.riと表わすことにする。

図５−１及び図５−２では、合成トランザクションT_G1,G2は、時間経過とともに、レコードD.r6,D.r7,D.r8,D.r9,D.19,D.r14,D.r3,D.22,D.23,E.r6,E.r14, E.r10の順にロックをかけて、すべてのロックをかけた後に、マルチオペレーション・プロセッシングによるレコードの処理が終了したレコードから順番にロックをはずしていることが示されている。
合成トランザクションT_G3,G4,G5の処理も同様に、時間経過とともに、レコードP.r9,P.r18,E.r11,E.r21,D.r13,D.r14,D.r15,D.r19の順番にロックをかけ、すべてのロックをかけた後に、マルチオペレーション・プロセッシングによるレコードの処理が終了したレコードから順番にロックをはずしている。合成トランザクションT_G1,G2と合成トランザクションT_G3,G4,G5に含まれるトランザクションは、T₂, T₉, T₃, T₁₁,T₁₀,T₇,T₁,T₅,T₈,T₄,T₆の順番でコミットしている。

二相ロックを用いたマルチオペレーション・プロセッシングは、ロックをかける実行順によってはデッドロックを生じる場合がある。例えば、図６の合成トランザクションT _G1,G2は、レコードD.r14に対してロックをかけようとし、合成トランザクションT_G3,G4,G5は、レコードD.r19に対してロックをかけようとしているけれども、お互いに必要なレコードを先にロックし合っているためデッドロックの関係にある。
このデッドロックを解除するには、合成トランザクションT_G1,G2,又は合成トランザクションT_G3,G4,G5のどちらかを中断することになるが、合成トランザクションT_G1,G2は、１つのトランザクションT₂をすでにコミットしていて、合成トランザクションT_G3,G4,G5は２つのトランザクションT₁₁,T₉をすでにコミットしているため、コミットしたトランザクションの数が少ない方の合成トランザクションT_G1,G2の処理を中断することになる。合成トランザクションT_G1,G2の処理を中断するには、すでにコミットしたトランザクションT₂はそのままにしておき、まだコミットしていないトランザクションT₇,T₃,T₁,T₅,T₈,T₄,T₆だけを中断してロックバックし、中断したトランザクションをトランザクション処理システム(100)に再提出することになる。
このようにして、個々の合成トランザクションに対して、二相ロックを用いたマルチオペレーション・プロセッシングを用いて処理を行うことによって、複数の合成トランザクションが同時に同一のデータ項目に対して更新処理を行うことがなくなり、データの矛盾が起こることはなくなる。

<タイムスタンプを用いたマルチオペレーション・プロセッシング>
タイムスタンプを用いたマルチオペレーション・プロセッシングは、複数の合成トランザクションの処理を同時に実行するにあたって、個々の合成トランザクションにタイムスタンプを与え、タイムスタンプの小さい合成トランザクションから順番に処理していく。タイムスタンプを用いたマルチオペレーション・プロセッシングが、従来のタイムスタンプ・プロトコルと異なる点は、従来のように個々のトランザクションに対してタイムスタンプを与えるのではなく、個々の合成トランザクションに対してタイプスタンプを与えることであり、また、個々のトランザクションが処理を行うデータ項目に対してタイムスタンプを与えるのではなく、個々の合成トランザクションが処理を行うデータ項目に対してタイムスタンプを与えることである。なお、複数の合成トランザクションの間でデータの矛盾が起こった場合は、データの矛盾が起こった合成トランザクションの処理を中断することになる。合成トランザクションの処理を中断するには、合成トランザクションに含まれるトランザクションの中ですでにコミットしたトランザクションはそのままにしておき、まだコミットしていないトランザクションだけを中断してロールバックして、トランザクション処理システムに再提出することになる。

<タイムスタンプを用いたマルチオペレーション・プロセッシングの手順>
タイムスタンプを用いたマルチオペレーション・プロセッシングは、複数の合成トランザクションが処理を行うデータ項目Xに対して、読み込みタイムスタンプread_TS(X)と書き込みのタイムスタンプwrite_TS(X)を与える。
read_TS(X)は、データ項目Xを読み込むことに成功したいくつかの合成トランザクションの中で、最もタイムスタンプの大きい合成トランザクションのタイムスタンプである。
write_TS(X)は、データ項目Xを書き込むことに成功したいくつかの合成トランザクションの中で、最もタイムスタンプの大きい合成トランザクションのタイムスタンプである。
合成トランザクションのタイムスタンプは、TS(T_G1,G2,…Gn)として表わし、合成トランザクションに含まれる個々のトランザクションに対してタイムスタンプ(到着時間)を与え、タイムスタンプを与えられたトランザクションの中で、最もタイムスタンプの大きいトランザクションのタイムスタンプを合成トランザクションのタイムスタンプとする。
合成トランザクションT_G1,G2,…Gnがデータ項目Xに対して書き込み処理write_item(X)、読み込み処理read_item(X)を行う場合は、次の規約に従って実行していくことになる。

ケース１ 項目Ｘに対する書き込み処理：
合成トランザクションT_G1,G2,…Gnがデータ項目Xに対しての書き込み処理write_item(X)を要求した場合
ａ．read_TS(X) > TS(T_G1,G2,…Gn)、又はwrite_TS(X) > TS(T_G1,G2,…Gn)であるならば、合成トランザクションT_G1,G2,…Gnの処理を中断し、合成トランザクションT_G1,G2,…Gnに含まれるトランザクションの中で、まだコミットしていないトランザクションの処理を中断する。中断したトランザクションはロールバックし、トランザクション処理システムに再提出する。
ｂ．aの条件を満たさない場合は、合成トランザクションT_G1,G2,…Gnのwrite_item(X)を実行し、write_TS(X)の値をTS(T_G1,G2,…Gn)とする。

ケース２ 項目Ｘに対する読み込み処理：
合成トランザクションT_G1,G2,…Gnがデータ項目Xに対して読み込み処理read_item(X)を要求した場合
ａ．write_TS(X) > TS(T_G1,G2,…Gn)であるならば、合成トランザクションT_G1,G2,…Gnの処理を中断し、T_G1,G2,…Gnに含まれるトランザクションの中でまだコミットされていないトランザクションの処理を中断する。中断したトランザクションはロールバックし、トランザクション処理システムに再提出する。
ｂ．write_TS(X) ≦ TS(T_G1,G2,…Gn)であるならば、T_G1,G2,…Gnのread_item(X)を実行し、TS(T_G1,G2,…Gn)の値がread_TS(X)よりも大きければ、read_TS(X)の値をTS(T_G1,G2,…Gn)とする。
次に、タイムスタンプを用いたマルチオペレーション・プロセッシングの手順を用いて、合成トランザクションT_G1,G2と合成トランザクションT_G3,G4,G5の処理を同時に行った場合について説明することにする。

<タイムスタンプを用いたマルチオペレーション・プロセッシングの具体例>
図７は、タイムスタンプを用いたマルチオペレーション・プロセッシングを使用して合成トランザクションT_G1,G2と合成トランザクションT_G3,G4,G5の処理を同時に実行しているのを表わしている。
合成トランザクションT_G3,G4,G5は、レコードD.r19に対して更新処理を行うにあたって、合成トランザクションT_G1,G2がレコードD.r19を読み出した（S704)後に、レコードD.r19を読み出している(S706)けれども、合成トランザクションT_G1,G2よりも先にレコードD.r19を書き込んでいる(S708)。そのため、その後に、合成トランザクションT_G1,G2がレコードD.r19を書き込む(S709)と、合成トランザクションT_G3,G4,G5が書き込んだr19に対する値が上書きされるため、合成トランザクションT_G1,G2の処理を中断することになる。タイムスタンプを用いたマルチオペレーション・プロセッシングがどのようにして、このデータの矛盾を見つけるかは次に述べるとおりである。

合成トランザクションT_G1,G2のタイムスタンプを8(合成トランザクションT_G1,G2に含まれるトランザクションの中で最もタイムスタンプの大きいトランザクションT₈のタイムスタンプを8とした場合)とし（S701）、合成トランザクションT_G3,G4,G5のタイムスタンプを11(合成トランザクションT_G3,G4,G5に含まれるトランザクションの中で最もタイムスタンプの大きいトランザクションT₁₁のタイムスタンプを11とした場合)とした（S702）とする。

最初に、合成トランザクションT_G1,G2がレコードD.r19を読み出すときに、write_TS(D.r19)の値が0（初期の値）であったとすると、ケース２のbの条件write_TS(D.r19) ≦ TS(T_G1,G2)を満たすため、read_item(D.r19)を実行し（S703)、read_TS(D.r19) の値を8とする（S704）。
次に、合成トランザクションT_G3,G4,G5がレコードD.r19を読み出す(S705)ときに、write_TS(D.r19)の値が0であったとすると、TS(T_G3,G4,G5)の値は11であり、ケース２のbの条件write_TS(D.r19) ≦ TS(T_G5)を満たすために、read_item(D.r19)を実行し(S705)、read_TS(D.r19)の値を8から11にする（S706)。

次に、合成トランザクションT_G3,G4,G5がレコードD.r19に書き込み処理write_item(D.r19)を要求する場合（S707)、ケース１のaのread_TS(D.r19) > TS(T_G3,G4,G5), 又はwrite_TS(D.r19) > TS(T_G3,G4,G5)の条件を満たすかどうかを確認する。read_TS(D.r19)の値は11、write_TS(D.r19)の値は0、TS(T_G3,G4,G5)の値は11であり、ケース１のaの条件を満たさないので、ケース１のbのwrite_item(D.r19) を実行し（S707)、write_TS(D.r19)の値を11とする（S708)。

次に、合成トランザクションT_G1,G2がデータ項目D.r19の書き込み処理write_item(D.r19)を要求する場合（S709)、ケース１のaのread_TS(D.r19) > TS(T_G1,G2), 又はwrite_TS(D.r19) > TS(T_G1,G2)の条件を満たすかどうかを確認する。read_TS(D.r19)の値は11、write_TS(D.r19)の値は11、TS(T_G1,G2)の値は8であり、ケース１のaの条件を満たしているので、合成トランザクションT_G1,G2の処理を中断することになる。
合成トランザクションT_G1,G2を中断するには、合成トランザクションT_G1,G2に含まれるトランザクションの中ですでにコミットしたトランザクションT₂はそのままにしておき、まだコミットしていないトランザクションT₇, T₃, T₁, T₅, T₈, T₄, T₆の処理を中断し、ロールバックすることになる。中断されたトランザクションT₇, T₃, T₁, T₅, T₈, T₄, T₆は、トランザクション処理システムに再提出する。
このようにして、タイムスタンプを用いて複数の合成トランザクションの処理を行うのがタイムスタンプを用いたマルチオペレーション・プロセッシングである。

[３．高度なクエリーがトランザクションに含まれている場合のトランザクション処理]
結合演算の処理を行うクエリーなど、複雑で高度なクエリーがトランザクションに含まれている場合、どのようにしてトランザクションを処理するかを、具体例を用いて説明する。図３−１のリレーションDEPARTMENT(300)と図３−２のリレーションEMPLOYEE(400)に対して、下記に示すような処理を行う３つのトランザクションT₁₂,T₁₃,T₁₄がトランザクション処理システムに入力されたとする。

(T₁₂):BEGIN WORK;
-- T₁₂の更新処理１
UPDATE DEPARTMENT
SET BUDGET = BUDGET + 9000
WHERE DNUMBER = 7;
-- T₁₂の更新処理２
UPDATE EMPLOYEE
SET MGRSSN = 470191111
WHERE SSN > 1876767888 AND SSN < 2111111124;
-- T₁₂のクエリー１
SELECT *
FROM DEPARTMENT, EMPLOYEE
WHERE DNUMBER = 7 AND
SSN > 2111111124 AND SSN < 2411111133 AND
DNUMBER = DNUM;
COMMIT WORK;

(T₁₃):BEGIN WORK;
-- T₁₃の更新処理１
UPDATE EMPLOYEE
SET DNUM = 8
WHERE SSN = 2311111132;
COMMIT WORK;
-- T₁₃のクエリー１
SELECT *
FROM DEPARTMENT, EMPLOYEE
WHERE DPHONE = '23-3711' AND
SSN > 2834567894 AND DNUM = DNUMBER;
-- T₁₃の更新処理２
UPDATE DEPARTMENT -- T₂の更新処理１
SET DNAME = 'SHIPPING'
WHERE DNUMBER = 7;
COMMIT WORK;

(T₁₄):BEGIN WORK;
-- T₁₄の更新処理1
UPDATE EMPLOYEE
SET PHONE = '23-5600'
WHERE SSN = 2311111132;
-- T₁₄の更新処理２
UPDATE DEPARTMENT
SET BUDGET = BUDGET + 4000
WHERE DNUMBER > 6 AND DNUMBER < 9;
COMMIT WORK;

入力されたトランザクションの処理を行うにあたって、トランザクションに含まれる結合演算の処理を行うクエリーに対しては、処理ツリーを作成する必要がある。トランザクションT₁₂,T₁₃には、それぞれ結合演算の処理を行うクエリー含まれているので、トランザクション処理システムは、クエリーの最適化を用いて、それらのクエリーに対して、図８に示す処理ツリー(a),(b)を作成する。処理ツリー内の結合演算は|X|で表わし、選択演算はσで表わすことにする。
処理ツリーを作成すると、トランザクション処理システムは、トランザクションT₁₂,T₁₃,T₁₄に対して、トランザクションに含まれる部分処理をタスクとして表わし、トランザクションの部分処理を作成すると次のようになる。

(T₁₂):
(t₁₂ ¹):read_item(D.r7);
D.r7.BUDGET := D.r7. BUDGET + 9000;
write_item(D.r7);
(t₁₂ ²):read_item(E.r9);
E.r9.MGRSSN := 470191111;
write_item(E.r9);
read_item(E.r10);
E.r10.MGRSSN := 470191111;
write_item(E.r10);
(t₁₂ ³):read_item(D.r7);
(t₁₂ ⁴):read_item(E.r12);
read_item(E.r13);
(t₁₂ ⁵):TEMP_T12_3 |X|_DNUMBER=DNUMTEMP_T12_4;

(T₁₃):
(t₁₃ ¹):read_item(E.r13);
E.r13.DNUM = 8;
write_item(E.r13);
(t₁₃ ²):read_item(D.r6);
(t₁₃ ³):read_item(E.r19);
read_item(E.r20);
(t₁₃ ⁴):TEMP_T13_2 |X|_DNUMBER=DNUMTEMP_T13_3;
(t₁₃ ⁵):read_item(D.r7);
D.r7.DNAME := 'SHIPPING';
write_item(D.r7);

(T₁₄):
(t₁₄ ¹):read_item(E.r13);
E.r13.PHONE := '23-5600';
write_item(E.r13);
(t₁₄ ²):read_item(D.r7);
D.r7.BUDGET := D.r7.BUDGET + 4000;
write_item(D.r7);
read_item(D.r8);
D.r8.BUDGET := D.r8.BUDGET + 4000;
write_item(D.r8);

上記のタスクt₁₂ ³は、図８(a)の処理ツリー内の選択演算σ_DNUMBER=7DEPARTMENTを処理するためのタスクである。
上記のタスクt₁₂ ⁴は、図８(a)の処理ツリー内の選択演算σ_{SSN>2111111124 AND SSN<2411111133} EMPLOYEEを処理するためのタスクである。
上記のタスクt₁₃ ²は、図８(b)の処理ツリー内の選択演算σ_{DPHONE = '23-3711'}DEPARTMENTを処理するためのタスクである。
上記のタスクt₁₃ ³は、図８(b)の処理ツリー内の選択演算σ_{SSN > 2834567894}EMPLOYEEを処理するためのタスクである。

上記のタスクt₁₂ ⁵は、図８(a)の処理ツリー内の結合演算であり、トランザクションの部分処理ではTEMP_T12_3|X|_DNUMBER=DNUMTEMP_T12_4としておく。TEMP_T12_3は、タスクt₁₂ ³の選択処理を行ったときに作成される一時表であり、TEMP_T12_4はタスクt₁₂ ⁴の選択処理を行ったときに作成される一時表である。タスクt₁₂ ⁵の結合処理は一時表TEMP_T12_3,TEMP_T12_4ができたときに、実行されることになる。
上記のタスクt₁₃ ⁴は、図８(b)の処理ツリー内の結合演算であり、トランザクションの部分処理ではTEMP_T13_2 |X|_DNUMBER=DNUMTEMP_T13_3としておく。TEMP_T13_2は、タスクt₁₃ ²の選択処理を行ったときに作成される一時表であり、TEMP_T13_3はタスクt₁₃ ³の選択処理を行ったときに作成される一時表である。タスクt₁₂ ⁵の結合処理は一時表TEMP_T13_2,TEMP_T13_3ができたときに、実行されることになる。

トランザクションの部分処理を作成すると、トランザクションの実行順を決定する。トランザクションの実行順を決定するには、トランザクションに含まれる部分処理をもとにして、トランザクションの処理コストを求め、トランザクションの処理コストの小さい順にトランザクションを並べてトランザクションの実行順を決定することにする。
トランザクションT₁₂の処理コストを6とし、トランザクションT₁₃の処理コストを5とし、トランザクションT₁₄の処理コストを2とした場合、トランザクションの実行順をT₁₄,T₁₃,T₁₂と決定することができる。

トランザクションの実行順を決定すると、トランザクションの実行順にデータを更新することを示した図８(c)の先行グラフに作成する。
トランザクションT₁₃,T₁₂は同一のレコードD.r7,E.r13に対して処理を行うため、トランザクションの実行順に接点T₁₃から接点T₁₂へと枝を入力する。
トランザクションT₁₄,T₁₃は同一のレコードD.r7,E.r13に対して処理を行うため、トランザクションの実行順に接点T₁₄から接点T₁₃へと枝を入力する。
トランザクションT₁₄,T₁₂は同一のレコードE.r13に対して処理を行うため、トランザクションの実行順に接点T₁₄から接点T₁₂へと枝を入力する。

先行グラフを作成すると、トランザクションの実行順にトランザクションT₁₄,T₁₃,T₁₂に含まれる部分処理をタスクとして取り出し、取り出したタスクを、トランザクションの実行順に、データベースのリレーションごとにグループ分けすると次のようになる。
DEPARTMENT: グループ G6 = {t₁₄ ², t₁₃ ², t₁₃ ⁵, t₁₂ ¹, t₁₂ ³}
EMPLOYEE: グループ G7 = {t₁₄ ¹, t₁₃ ¹, t₁₃ ³, t₁₂ ², t₁₂ ⁴}
TEMP_T13_3: グループ G8 = {t₁₃ ⁴}
TEMP_T12_4: グループ G9 = {t₁₂ ⁵}

結合演算のタスクをグループ分けするには、結合演算の検索元に使用する一時表をリレーションとみなしてグループ分けすることになり、一時表TEMP_T13_3を結合演算の検索元に使用するタスクt₁₃ ⁴をグループG8集め、一時表TEMP_T12_4を結合演算の検索元に使用するタスクt₁₂ ⁵をグループG9に集めることにする。
タスクがグループ分けされて、グループG6,G7,G8,G9が作成されると、グループG6,G7,G8,G9を用いて合成トランザクションT_G6,G7,G8,G9を作成し、合成トランザクションT_G6,G7,G8,G9に含まれる個々のグループに対して、第一章で述べたマルチオペレーション・プロセッシングを用いて処理することになる。

グループの処理を行うにあたって、グループG8内のタスクt₁₃ ⁴の結合処理は、グループG6内のタスクt₁₃ ²の選択処理とグループG7内のタスクt₁₃ ³の選択処理が終了してから始めることなる。
また、グループG9内のタスクt₁₂ ⁵の結合処理はグループG6内のタスクt₁₂ ³の選択処理とグループG7内のタスクt₁₂ ⁴の選択処理が終了してから始めることになる。
最初にグループG6とグループG7の処理が終了すると、トランザクションT₁₄内のすべてのタスクの処理が終了することになるので、トランザクションT₁₄の処理が終了してコミットすることになる。トランザクションT₁₄がコミットすると、図13(c)の先行グラフから接点T₁₄とその接点から出ているすべての枝を削除する。その結果は、図13(d)の先行グラフとして表わすことができる。

次にグループG8の結合処理が終了してタスクt₁₃ ⁴の処理が終了すると、トランザクションT₁₃内のすべてのタスクの処理が終了するので、トランザクションT₁₃が終了してコミットすることになる。トランザクションT₁₃がコミットすると、図13(d)の先行グラフから接点T₁₃とその接点から出ているすべての枝を削除する。その結果は図13（e)先行グラフとして表わすことができる。
最後にグループG9の結合処理が終了してタスクt₁₂ ⁵の処理が終了すると、トランザクションT₁₂内のすべてのタスクが終了するので、トランザクションT₁₂の処理が終了してコミットすることになる。その結果、合成トランザクションT_G6,G7,G8,G9の処理が完了し、入力されたトランザクションT₁₂,T₁₃,T₁₄の処理がすべて終了し、コミットしたことになる。

以上に述べたように、本発明のトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングは、高度なクエリー処理がトランザクションに含んでいる場合にも対応することができる。

[４. 実験結果]
本章では、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングによるトランザクション処理の評価のために行った実験とその結果について考察する。実験では、第１章で述べた本発明のトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングによるトランザクションの処理時間と、トランザクションの処理を別々に行う従来の二相ロック・プロトコルによるトランザクションの処理時間を測定し、両者の処理時間を比較した。

トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングの処理は、トランザクション処理システムに入力された複数のトランザクションに対して1.1節で述べた手順にしたがって合成トランザクションを作成し、合成トランザクションの処理を行い、１つの合成トランザクションの処理が終了した段階で、新たに数多くのトランザクションが入力されると、同様な手順を用いて別の合成トランザクションを作成し、その合成トランザクションの処理を行っていき、合成トランザクションの処理を順次１つずつ実行した。また、合成トランザクションに含まれる複数のグループの処理は、オペレーティング・システムの複数のプロセスを用いて同時に並行して実行した。

実験を行うには、Windows XP Professional(登録商標)を搭載したパーソナルコンピューター(1つのCeleron CPU 1.73GHzプロセッサ、1GBメインメモリ、1つの145GBディスク)をデータベース・サーバーとして使用した。データベース・サーバーには、独自に開発したデータベース・マネージメント・システムのソフトウェアMOP-DBをインストールし、このソフトウェアを用いて、6つのリレーションから構成されるデータベースを作成し、個々のリレーション対して、主インデックス、2次インデックスなどのインデックスを加えた。MOP-DBのソフトウェアは、従来の二相ロック・プロトコルによるトランザクションの処理と、本発明のトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングによるトランザクションの処理の両方ができるように開発しておいた。
次に、独自のクライアントプログラムを作成し、クライアントプログラムからSQLで記述された数多くのトランザクションをデータベース・サーバーに入力し、データベース・サーバーによってすべてのトランザクションが処理されてコミットするまでの時間を測定して、それぞれの手法によるトランザクションの処理時間を求めた。

＜実験１: トランザクションの数の影響＞
各リレーションに100万件ずつレコードを格納し、6つのリレーションに対して合計600万件ほどのレコードをデータベースに加え、データベースに同時に問い合わせるトランザクションの数を1000件から10000件まで変化させたときの処理時間を図９(a).(b)の表とグラフに示した。トランザクションの処理時間が速くなることは処理速度が速くなることであると考えると、トランザクションの数が1000件から10000件までの件数において、全体的にトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングの処理速度のほうが従来の二相ロック・プロトコルの処理速度よりも速いことがわかる。トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングは、トランザクションの数が1000件から5000件までは、図９(a)の表から、従来の二相ロック・プロトコルの処理速度よりも平均して18.36倍の処理速度が得られ、トランザクションの数が6000件から10000件までは、従来の二相ロック・プロトコルの処理速度よりも平均して19.98倍の処理速度が得られた。

トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングは、トランザクションの数が増えるにつれて処理速度も速くなっていく傾向がある。
図9(b)のグラフに示すように、従来の二相ロック・プロトコルは、トランザクションの数が増えると、数多くのトランザクションが同一のデータ項目を何度も繰り返して読み出し、読み出したレコードに対して更新処理を別々に行い、更新された結果を何度も繰り返してデータベースに書き込むため、トランザクションの処理速度が低下することになった。
一方、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングは、同時に処理するトランザクションの数が増加すると、複数のトランザクションが処理を行う同一のデータ項目を一度だけ読み出し、読み出したレコードに対して複数のトランザクションの更新処理を順次メインメモリ内で行い、最後に更新された結果だけをデータベースに一度だけしか書き込まないので、トランザクションの処理速度が向上した。

＜実験２: データベースサイズの影響＞
データベースの6つのリレーションに格納されるレコード数を60万件から600万件へと変化させ、それぞれのサイズのデータベースに10000件のトランザクションの処理を一度に要求したときの処理時間を図10(a).(b)の表とグラフに示した。
図10(a).(b)の表とグラフに示すように、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングは、レコード数が60万件から300万件までは、従来の二相ロック・プロトコルの処理速度よりも平均して8.04倍の処理速度が得られ、レコード数が360万件から600万件までは、従来の二相ロック・プロトコルの処理速度よりも平均して15.59倍の処理速度が得られ、データベースのサイズが大きくなるにつれて、処理速度が向上していく傾向がある。従来の二相ロック・プロトコルは、データベースのサイズが大きくなるにつれ、個々のトランザクションの処理に時間がかかるようになった。一方、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングは、データベースのサイズに関係なく効率よく個々の合成トランザクションの処理を実行することができた。

[５. おわりに]
トランザクション処理システムに入力された複数のトランザクションを処理するにあたって、個々のトランザクションを別々に処理することによって発生する従来の問題を解決するために、トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを提案した。
このシステムは、トランザクション処理システムに複数のトランザクションが入力されると、入力されたトランザクションに対して、トランザクションの部分処理を求め、トランザクションの実行順を決定し、決定した順にデータを更新することを示した先行グラフを作成し、トランザクションに含まれる個々の部分処理をタスクとして取り出し、取り出したタスクを、トランザクションの実行順にデータベースのリレーションごとにグループ分けし、グループ分けして作成したグループを用いて合成トランザクションを作成し、合成トランザクションに含まれる個々のグループに対してマルチオペレーション・プロセッシングを用いて処理を行っていくシステムである。

マルチオペレーション・プロセッシングは、グループにタスクが並んだ順にブロックへのアクセス順を決定し、決定したアクセス順にブロックを読み出し、読み出したブロックにアクセスするタスクをグループ内から抽出し、ブロック内のデータ項目に対して、グループ内のタスクが並んだ順にタスク処理を順次行っていく。
ブロック内のデータ項目に対して、グループ内のタスクが並んだ順にタスク処理を順次行っていくということは、ブロック内のデータ項目が先行グラフに存在する場合、そのデータ項目に対して先行グラフに示したトランザクションの実行順にトランザクションの部分処理であるタスク処理を順次行っていくことであり、複数のタスクがそのデータ項目に対して更新処理を行う場合、そのデータ項目に対して最初のタスクの更新処理を行い、更新されたデータ項目に対して次のタスクの更新処理を行い、このような更新処理を繰り返し、最後のタスクの更新処理が行われると、最後に更新された更新結果だけをデータベースに書き込んでいくことである。

このシステムを用いることによって、従来のトランザクションの処理のように、入力された複数のトランザクションに対して、トランザクションごとに同じデータ項目を何度も繰り返して検索し、検索したデータ項目に対して更新処理を別々に行い、更新された結果を何度も繰り返してデータベースに書き込む必要がなくなった。
本発明のシステムは、複数のトランザクションが処理を行うデータ項目に対して、そのデータ項目を一度だけ検索し、検索したデータ項目に対して、複数のトランザクションの更新処理を順次メインメモリ内で行い、最後に更新した結果だけをデータベースに一度だけ書き込めばよいので、極めて効率的に複数のトランザクションの処理を行うことができるようになった。
本発明は、入力された複数のトランザクションに対して、サイクルを含んでいない先行グラフを作成し、複数のトランザクションによって処理されるデータ項目に対して、先行グラフに示したトランザクションの実行順にトランザクションの処理を順次行っていくので、入力された複数のトランザクションは直列可能スケジュール(serializable schedule)で処理される。

合成トランザクションに含まれる個々のグループの処理は、異なるリレーションに対して行うため、それらのグループの処理を同時に行っても、複数のグループ間で同一のデータ項目がアクセスされることはない。グループに集められたタスクの処理は、メインメモリに読み込まれたブロック内のデータ項目に対して、先行グラフに示したトランザクションの実行順に順次行っていくので、入力された複数のトランザクションの間でロックをかけたり、トランザクションを待たせたり、トランザクションを中断したりするといった必要がなくなった。
本発明は、入力された複数のトランザクションに対して１つの合成トランザクションを作成し、合成トランザクションの処理を行っていくことができ、１つの合成トランザクションの処理が終了した段階で、新たに複数のトランザクションが入力されると、それらのトランザクションに対して別の合成トランザクションを作成し、その合成トランザクションの処理を行っていくことができるので、合成トランザクションの処理を１つずつ実行していく場合には、ロックを用いる必要はなくなる。また、デッドロックなどを発生することもなく、合成トランザクションに含まれる複数のグループの処理を同時に並行して実行していくことができるようになった。
合成トランザクションを１つずつ実行していくことで十分にトランザクションの処理速度を向上させることができるが、CPUやディスクなどハードウェア資源を効率よく利用することを考慮する場合には、複数の合成トランザクションを同時に並行して実行することを取り上げ、これらの複数の合成トランザクションの処理を同時に並行して実行するために、二相ロックを用いたマルチオペレーション・プロセッシングとタイムスタンプを用いたマルチオペレーション・プロセッシングを提案した。

トランザクション処理システムのアーキテクチャの構成を示す図である。 トランザクション処理システムのフローチャートを示す図である。 トランザクション処理システムのフローチャートを示す図である。 データベースのリレーションの例を示す図である。 データベースのリレーションの例を示す図である。 複数のトランザクションによるデータの更新順を表わした先行グラフの例を示す図である。 二相ロックを用いたマルチオペレーション・プロセッシングの例を示す図である。 二相ロックを用いたマルチオペレーション・プロセッシングの例を示す図である。 複数の合成トランザクション間でのデッドロックの例を示す図である。 タイムスタンプを用いたマルチオペレーション・プロセッシングの例を示す図である。 処理ツリーと先行グラフの例を示す図である。 トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングの実験結果を示す（ａ）表，（ｂ）グラフである。 トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングの実験結果を示す（ａ）表，（ｂ）グラフである。

Claims (4)

1. トランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システムであって、
   入力された複数のトランザクションに対してトランザクションの実行順を決定するトランザクション実行順決定手段と、
   前記複数のトランザクションが同一のデータ項目に対して処理を行う場合、そのデータ項目に対する枝を作成し、先に処理を行うトランザクションの接点から次に処理を行うトランザクションの接点にその枝を入力して、前記トランザクションの実行順にデータを更新することを示した先行グラフを作成する先行グラフ作成手段と、
   前記複数のトランザクションに含まれる部分処理をタスクとして取り出すタスク取り出し手段と、
   前記取り出したタスクを、前記トランザクションの実行順に、前記データベースのアクセス領域ごとにグループ分けするグループ分け手段と、
   前記グループ分けして作成したグループを用いて合成トランザクションを作成する合成トランザクション作成手段と、
   前記合成トランザクションに含まれる個々のグループに対してマルチオペレーション・プロセッシングを用いて処理を行うマルチオペレーション・プロセッシング手段と
   を備え、
   前記マルチオペレーション・プロセッシング手段は、グループ分けされたタスクがアクセスするアクセス領域内のブロックを調べ、グループ内のタスクが並んでいる順に該ブロックへのアクセス順を決定し、決定したアクセス順に該ブロックを読み出し、読み出したブロックにアクセスするタスクをグループ内から抽出し、ブロック内のデータ項目に対して、グループ内のタスクが並んでいる順にタスク処理を順次行い、グループ分けされたタスクの処理が終了し、グループ分けされたタスクを包含するトランザクションの処理が終了すると、その時点で終了したトランザクションをコミットするかどうかを、前記先行グラフの終了したトランザクションの接点に入力枝が存在するかどうかで決定し、該トランザクションの接点に入力枝が存在しない場合は、該トランザクションをコミットし、該トランザクションの接点とその接点から出ているすべての枝を削除し、
   ブロック内のデータ項目に対して、グループ内のタスクが並んでいる順にタスク処理を順次行っていくということは、ブロック内のデータ項目が前記先行グラフに存在する場合、そのデータ項目に対して前記先行グラフに示したトランザクションの実行順にトランザクションの部分処理であるタスクの処理を順次行っていくことであり、
   複数のタスクがそのデータ項目に対して更新処理を行う場合、そのデータ項目に対して最初のタスクの更新処理を行い、更新されたデータ項目に対して次のタスクの更新処理を行い、このような更新処理を繰り返し、最後のタスクの更新処理が行われると、最後に更新された更新結果だけをデータベースに書き込む
   ことを特徴とするトランザクション処理システム。
2. 請求項１に記載のトランザクション処理システムにおいて、
   ２相ロック・プロトコル又はタイムスタンプ・プロトコルを用いて複数の合成トランザクションの処理を同時に並行して実行することを特徴とするトランザクション処理システム。
3. 請求項１又は２に記載のトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システムの各機能を、コンピュータ・システムに実現させるためのプログラム。
4. 請求項１又は２に記載のトランザクションの同時実行制御を備えたマルチオペレーション・プロセッシングを用いたデータベースのトランザクション処理システムの各機能を、コンピュータ・システムに実現させるためのプログラムを記録した記録媒体。

Images