JP4071816B1 - 合成関係演算を利用したマルチオペレーション・プロセッシングを用いたデータベースのクエリー処理システム - Google Patents

Abstract

【課題】クエリーの処理速度を向上させる。
【解決手段】クエリーの問い合わせが入力される（S110）と、関係演算で構成された処理ツリーに変換され（S120)、直接的に処理することのできるタスクを見つける（S130）。タスクを見つけると、共通のリレーションをアクセスするグループがグループ列に存在するかどうかを調べ（S140)、共通のリレーションをアクセスするグループがグループ列に存在しているならば、そのグループにタスクを加える（S150)。存在していない場合は、新たなグループを作成する(S160)。
グループ内の共通部分式を持つタスクは、さらにサブグループに集め(S170)、サブグループにタスクを集めると、サブグループ内のタスクをもとに合成関係演算タスクを作成する(S180)。グループ内の合成関係演算タスク等の処理を一度に行う(S190)。合成関係演算タスクの処理が終了すると、サブグループ内のタスクに対して仮想リレーションを作成して、合成関係演算タスクの処理結果として得られたリレーションを部分的に共有できるようにする(S200)。
【選択図】図２

Description

本発明は、データベースのクエリー処理システムに関し、特に、合成関係演算を利用したマルチオペレーション・プロセッシングを用いたクエリーの処理に関するものである。

データベース・マネージメント・システム（ＤＢＭＳ）に、一度に数多くのクエリーが問い合わせられると、データベース・マネージメント・システムは、トランザクションの同時処理制御機能を使用して、それぞれの問い合わせ処理を行っている。検索のみのトランザクションはクエリーと呼ばれ、データベース・マネージメント・システムは、問い合わせのあったクエリーを別々に処理しているが、この方法には次のような問題点がある。

問題点（１）：従来のデータベース・マネージメント・システムによるクエリー処理方法は、多くのクエリーが共通のリレーションに対して処理を行うと、ディスクから同じデータが何度もメインメモリに読み込まれてアクセスされ、アクセスするたびにブロック内のデータが繰り返しメインメモリに読み込まれて処理が行われる。このため、効率的ではなくクエリーの処理速度が低下するといった問題がある。

問題点（２）：従来のデータベース・マネージメント・システムによるクエリー処理方法は、クエリー内のタスク処理を行うたびに、クエリーの中間結果であるタスクの処理結果のリレーションをディスク上に作成している。それぞれのタスクの処理結果では、レコードや属性の選択範囲が重なっているため、ディスク上にレコードや属性の選択範囲の重なっている処理結果のリレーションを数多く作成することになる。このため、ディスクをアクセスする回数が多くなり、クエリーの処理速度が低下するといった問題がある。

問題点（３）：従来のデータベース・マネージメント・システムによるクエリー処理方法は、クエリーに含まれる結合演算の処理を行うとき、ハッシュ結合などの結合方法を用いている。このため、結合演算の処理を行うたびに、結合演算に使用する検索先のリレーション内のレコードをディスクからアクセスして、メインメモリ内にハッシュテーブル（ハッシュテーブルを検索先のリレーション内のレコードのインデックスとして使用する）を作成することになるので、ディスクをアクセスする回数が多くなり、クエリーの処理速度が低下するといった問題がある。

また、それぞれの結合演算に使用される検索先のリレーションは異なるので、個々の結合演算に対して別々にハッシュテーブルを作成する必要があり、一度に数多くのハッシュテーブルをメインメモリに作成すると、メインメモリに十分なスペースを確保することができなくなり、クエリーの処理速度が低下するといった問題が起こる。

（演算と演算結果のキャッシングの問題点）
ディスクをアクセスする回数を減少させてクエリーの処理速度を向上させるために、問い合わせの多いクエリーとクエリーの処理結果、クエリーに含まれる演算（選択演算，射影演算，結合演算などの関係代数）と演算の処理結果（クエリーの中間結果）を一時的にディスクに保存（キャッシング）しておく方法がよく用いられている。ユーザからクエリーの問い合わせがあると、データベース・マネージメント・システムは、問い合わせのあったクエリーと同じクエリーの処理結果がディスクに保存されているかどうかを調べて、保存されているならば、そのクエリーの処理を行わずに、保存されているクエリーの処理結果をそのままユーザに返すことになる。また、クエリーは異なるけれども、クエリーに含まれる演算と同じ演算の処理結果がディスクに保存されているならば、データベース・マネージメント・システムは、その演算の処理を行わずに、すでに存在する演算の処理結果を利用してクエリーの処理を行うことになる。

この方法は、保存するクエリーの処理結果、演算の処理結果を増やすことで、同じクエリーや演算の処理を繰り返して行うことなしに、クエリーの処理速度を向上させることを目的としている。しかし、この方法は、問い合わせのあったクエリーやクエリーに含まれる演算がディスクに保存しているものと同じでなければならないため、クエリーや演算が異なる場合は、保存されている処理結果を利用することはできない。また、この方法は、データベースに新たなレコードが加えられるなどしてデータベースが更新されると、保存されている処理結果は古くなるので、データベース・マネージメント・システムは、古くなった処理結果を破棄しなければならない。そのためデータベースの更新がたびたび行われると、その都度、古くなった処理結果を破棄しなければならないので、この方法は効率的ではなくなる。マイクロソフト社のＳＱＬサーバーなどのデータベース・マネージメント・システムは、クエリーの処理速度を維持するために、古くなったクエリーの処理結果をすぐには破棄せずに、しばらく古い処理結果をユーザに返すようにしている。

（メインメモリへのキャッシングの問題点）
ディスクをアクセスする回数を減少させてクエリーの処理速度を向上させるその他の方法は、クエリーを処理するためによくアクセスされるディスク上のブロックの複製をメインメモリに一時的に保存（キャッシング）しておく方法が用いられる。この方法は、ユーザからクエリーの問い合せがあると、データベース・マネージメント・システムは、クエリーを処理するためにディスクからアクセスするブロックの複製がメインメモリに保存されているかどうかを調べて、保存されているならば、メインメモリ内の複製を利用する。
この方法は、メインメモリ内で保存するブロックの容量を増やしておくことで、ディスクをアクセスする回数を減少させてクエリーの処理速度を向上させることを目的としている。

しかし、この方法は、ディスク上のブロックとメインメモリ上の複製が同じでなければならないため、ブロック内のデータを変更するときには、ディスク上のブロックとメインメモリ上の複製の両方を更新しておかなければならない。また、クエリーを処理するために数ギガバイト（ＧＢ）もあるようなデータベースのリレーションを線形探索（スキャン）するような場合は、メインメモリに保存されているブロック以外のほとんどのブロックをディスクからアクセスすることになるので有効ではなくなる。
また、オペレーティング・システム自体もこのようなメモリー管理を行っているため、データベース・マネージメント・システムがメインメモリに保存するブロックの容量を増やすと、メインメモリに保存されたはずのブロックがオペレーティング・システムによって仮想メモリー（ディスク）に移動されることなどが起こり、逆にクエリーの処理速度が低下するといった問題が発生する。

（クエリー処理のパイプライン化の問題点）
クエリーの中間結果であるタスクの処理結果のリレーションをディスク上に作成しないで、ディスクをアクセスする回数を減少させてクエリーの処理速度を向上させる方法としては、クエリー処理をパイプライン化した方法が用いられる。
クエリー処理をパイプライン化した方法とは、複数のマイクロプロセッサを備えているコンピュータ・システムにおいて、クエリーに含まれるいくつものタスク処理を複数のマイクロプロセッサを用いてパイプラン化し、個々のタスク処理を並列に処理していく方法である。この方法は、クエリーに含まれる個々のタスクの処理結果はストリーム化され、個々のタスク処理が完全に終了するのを待たずして、部分的に終了したタスクの処理結果に対する次のタスク処理を行っていくものである。しかし、パイプライン化できるタスク処理は、選択演算や射影演算などのタスクに限られ、結合演算などのタスクは、結合演算の前に行われるタスク処理が完全に終了してからではないと処理を始めることができないので、パイプライン化することはできない。また、クエリー処理をパイプライン化した方法は、複数のマイクロプロセッサを搭載してあるコンピュータ・システムが必要であるので、マイクロプロセッサを１つしか備えていないコンピュータ・システムでは有効ではない。

発明者が参考にした参考文献を以下に記載する。
問い合わせの多いクエリーとクエリーの処理結果、クエリーに含まれる演算（選択演算、射影演算、結合演算などの関係代数）と演算の処理結果(クエリーの中間結果) を一時的にディスクに保存(キャッシング)しておくことを記載したものとして、以下に記載する非特許文献１〜６がある。
クエリーを処理するためにアクセスされるディスク上のブロックの複製をメインメモリーに一時的に保存(キャッシング)しておくことを記載したものとして、非特許文献７〜１１がある。
また、クエリー処理のパイプライン化を記載したものとしては、非特許文献１２がある。
Finkelstein, S. Common Expression Analysis in Database Applications. In Proceedings of the International Conference of the Management of Data(SIGMOD'82, Orland, Florida, June 2-4), 1982 Yigal Arens and Craig A. Knoblock. Intelligent Cashing: Selecting, Representing and Reusing Data in an Information Server. ACM Press, Proceedings of the third international conference on Information and knowledge management, November 1994 Hyunchul Kang, Seungchul Han, Younghyum Kim. Schemes of Storing XML Query Cache. Proceedings of the sixteenth Australasian database conference, Volume 39 ADC 2005 Bhushan Mandhani, Dan Suciu, Query Caching and View Selection for XML Databases, Proceedings of the 31st international conference on Very large data bases,VLDB 2005 Michael J. Carey, Michael J. Franklin, Miron Livny, and Eugene J. Shekita. Data caching tradeoffs in client-server DBMS architectures. In Proceedings of the ACM SIGMOD, pages 357-366, 1991 TIMOS K. SELLIS. Multiple-Query Optimization. ACM Transactions on Database Systems, Vol. 13, No. 1, Pages 23-52, March 1988. Giovanni Mario Sacco and Mario Schkolnick. Buffer Management in Relational Database Systems. ACM Transactions on Database Systems, Volume 11, no. 4, pp. 473-498, December 1986 Chou, H. And DeWitt, D. An Evaluation of Buffer Management Strategies for Relational Database Systems. Proceedings of VLDB, 1985 O'Neil EJ, O'Neil PE, Weikum G. The LRU-K Page Replacement Algorithm For Database Disk Buffering. In ACM SIGMOD Conf., 1993, Washington, D.C., pp 297-306 Zhifeng Chen, Yan Zhang, Yuanyuan Zhou. Empirical Evaluation of Multi-level Buffer Cache Collaboration for Storage systems. ACM SIGMETRICS international conference on Measurement and modeling of computer systems SIGMETRICS 2005, Volume 33 Issue 1 Michael Stonebraker. Operating System Support for Database Management. Communications of The ACM, 24(7):412-18, July 1981 David J. DeWitt and Jim Gray. Parallel Database Systems: The Future of High Performance Database Processing. Communications of The ACM, Vol. 36, No. 6, June 1992

以上に述べたような解決方法は、数多くのデータベース・マネージメント・システムに採用されているが、問題点もあるために必ずしも効率的な方法ではない。
本発明では、これらの解決方法とは別に、独自に考案するクエリーの処理方法を用いて、ディスクをアクセスする回数を減少させ、クエリーの処理速度を向上させる方法を提案する。

上記発明の目的を達成するために、本発明は、合成関係演算を利用したマルチオペレーション・プロセッシングを用いたデータベースのクエリー処理システムであって、前記クエリーを関係代数による処理ツリーに変換する処理ツリー変換手段と、前記処理ツリーから、トポロジカルソートにより、関係代数を他の関係代数の結果に依存しないで実施できる順番に、タスクとして取り出すタスク取り出し手段と、前記取り出したタスクを、前記データベースのリレーションごとにグループ分けするグループ分け手段と、グループ分けされた前記タスクに対して、共通部分式を持つタスクをさらにサブグループに集め、合成関係演算タスクを作成する合成関係演算作成手段と、前記グループ分けされたタスクごとに、作成された前記合成関係演算タスクとサブグループに集まらないタスクとに対してマルチオペレーション・プロセッシングを行うマルチオペレーション・プロセッシング手段と、グループ内の前記合成関係演算タスクの処理結果として得られたリレーションに対して、前記合成関係演算に含まれる個々のタスクが、そのリレーションのレコード及び／又は属性を部分的に共有するように、格納位置による仮想リレーションを作成する仮想リレーション作成手段とを備え、前記グループ分け手段は、前記合成関係演算タスクの処理結果として得られたリレーションごとにも、タスクをグループ分けすることを特徴とする。

前記合成関係演算作成手段は、サブグループに集めた複数の選択演算タスクで使用する属性名と属性数が等しいときに、それらの属性の中の１つの属性に関する選択条件だけが異なった条件かまたは同じ条件であり、それ以外の属性に関する選択条件はまったく同じであるならば、それらの選択条件をブール演算のＯＲを使用して接続し、接続した選択条件から選択範囲の重複した部分を取り除くために、簡潔化して最適化した選択条件を作成し、その選択条件を用いて複数の選択演算タスクの合成関係演算を作成するとよい。
前記合成関係演算作成手段は、サブグループに集めた複数の射影演算タスクが、共通のリレーションに対して射影演算の処理を行うならば、これらの射影演算タスクの属性の和集合を求めて得られた属性を用いて、複数の射影演算タスクの合成関係演算を作成するとよい。
前記仮想リレーション作成手段は、仮想リレーションのレコードに対してタスクが検索処理を行う場合、仮想リレーションが部分的に共有するリレーションの検索に使用する属性に対して、インデックスを作成するとよい。
上述した合成関係演算を利用したマルチオペレーション・プロセッシングを用いたデータベースのクエリー処理システムの各機能を、コンピュータ・システムに実現させるためのプログラムやプログラムを記録した記録媒体も本発明である。

独自のタスクに関する共通部分式を定義し、合成関係演算を利用したマルチオペレーション・プロセッシングを用いたクエリー処理を行うことによって、マルチオペレーション・プロセッシングのみを用いたクエリー処理よりも効率よくクエリー処理を行うことができるようになった。
その方法は、グループ内の共通部分式を持つタスクをさらにサブグループに集めて、サブグループに集めたいくつかのタスクを１つの合成関係演算タスクに置き換えて処理を行うことになる。また、サブグループ内の個々のタスクは、仮想リレーションを用いて、合成関係演算タスクの処理結果として得られたリレーションを部分的に共有することになり、従来のクエリー処理のように、選択範囲及び／又は属性の重なっている数多くの処理結果のリレーションをディスク上に別々に作成することがなくなり、ディスクをアクセスする回数を減少させ、クエリーの処理速度が向上させることができた。

また、仮想リレーションのレコードに対してタスクが検索処理を行う場合、仮想リレーションが部分的に共有する合成関係演算タスクの処理結果として得られたリレーションの検索に使用する属性に対して、インデックスを作成することによって、そのインデックスを他のタスクも共有して検索処理を行うことができるようになり、ディスクをアクセスする回数を減少させて、クエリーの処理速度を向上させることができた。

また、合成関係演算タスクの処理結果として得られたリレーションのアクセス領域ごとにも、タスクをグループ分けすることによって、そのリレーションの共通ブロック上でタスク処理を一度に行うことができるようになり、ディスクをアクセスする回数を減少させ、極めて効率的にタスク処理を行うことができるようになった。
実験の処理結果からもわかるように、これまで広く使用されているMySQL.Ver3や以前のマルチオペレーション・プロセッシングのみを用いたクエリー・プロセッサよりも一段と数多くのクエリーの処理を高速に行うことができるようになった。

従来の技術の問題点（１）の解決方法として、ディスクなどの２次記憶装置へのアクセスを減らしてクエリーの処理速度を向上させるために、本発明者も「マルチオペレーション・プロセッシングによるデータベースのクエリー処理の向上」について提案した（特願２００６−３５６４０６号参照）。マルチオペレーション・プロセッシングは、いくつかのタスクが共通のリレーションに対して処理を行うときに、それらのタスクをグループに集め、グループ内の各タスクに対してアクセスプランを作成し、アクセスプランをもとにして、それぞれのタスクによるディスク内のリレーションのブロックへのアクセスから得られる共通ブロック（Common Block）を見つけ、その共通ブロックを使用して、グループに集められたタスクの処理を一度に行うものである。

この方法は、それぞれのタスクごとにディスク内のブロックにアクセスすることを回避して、共通ブロックでいくつかのタスクを一度に処理することによって、クエリー（全体のタスク）の処理速度を向上させることをめざしている。このマルチオペレーション・プロセッシングの処理を行うに当たって、本発明者は、前述の出願において、ダイナミックマルチオペレーション・プロセッシング（Dynamic Multi-Operation Processing）とスタティックマルチオペレーション・プロセッシング（Static Multi-Operation Processing）との２つの処理方法を提案した。

ダイナミックマルチオペレーション・プロセッシングは、グループ内の各タスクに対してアクセスプランを作成し、アクセスプランから各タスクの処理コストを計算し、求められた処理コストを参照して、処理コストの小さいタスクから順番にタスク処理を行うものである。この処理では、当面のタスク（処理コストの小さいタスク）の処理を行うためにアクセスしたブロックにおいて、グループ内の他のタスクも処理を行う必要がある場合は、アクセスしたブロックは共通ブロックとなり、共通ブロックでこれらのタスク処理を一度に行う。当面のタスク処理が終了し、グループ内で次に処理コストの小さいタスクの処理を行うときは、すでにアクセスしたブロックでの当面のタスクを含むグループ内の個々のタスク処理は終了しているので、まだアクセスしていない残りのブロックの中から、次に処理コストの小さいタスク処理を行うために必要とされるブロックをアクセスする。アクセスしたブロックにおいて、グループ内の他のタスク（残りのタスク）も処理を行う必要がある場合は、アクセスしたブロックは共通ブロックとなり、共通ブロックでこれらのタスク処理を一度に行う。このようにしてグループ内の残りのタスクに対しても繰返してタスク処理を行っていくものである。

また、スタティックマルチオペレーション・プロセッシングは、グループ内の各タスクからアクセスプランを作成し、アクセスプランから各タスクの処理コストを求め、求めた処理コストを参照して、処理コストの１番小さいタスクから処理コストの１番大きいタスクへと順番にグループ内の各タスクを並べることにする。ここまでは、ダイナミックマルチオペレーション・プロセッシングと同じ手順である。次にデータベースのインデックスを使用して、グループ内の各タスクが、共通のリレーション内のブロックからタスク処理を行うためにアクセスする必要のあるブロックを調べて、各タスクに対応するブロック集合に集める。次に、前に求めた処理コストの小さいタスクから処理コストの大きいタスクまでの順番にしたがって、各タスクに対応するブロック集合の和集合を求めていくことによって、アクセスするブロックの順位を決定する。その順位にしたがって共通のリレーション内のブロックをディスクからアクセスし、このブロックを共通ブロックとして、このブロック上で処理を行う必要のあるグループ内のタスク処理を一度に処理していく方法である。この方法は、アクセスすべきブロック（共通ブロック）の順位にしたがって、和集合、積集合及び差集合などの集合論を用いて、クエリーに含まれる各タスクの処理をきわめて論理的に行うものである。

今回は、上述の問題点（１）の解決方法のさらなる改善と、問題点（２），（３）を解決するため、データベースに問い合わせのあった数多くのクエリーを効率よく処理することができる合成関係演算を利用したマルチオペレーション・プロセッシングを提案する。合成関係演算を利用したマルチオペレーション・プロセッシングは、マルチオペレーション・プロセッシングに独自に定義する合成関係演算を利用した処理方法を加えることによって、前述のマルチオペレーション・プロセッシングを用いたクエリーの処理よりもさらに数多くのタスクの処理を一度に行い、ディスクへのアクセスを少なくして、ユーザから問い合わせのあった数多くのクエリーをすばやく処理していく方法である。

以下で詳しく説明する合成関係演算を利用したマルチオペレーション・プロセッシングは、ユーザから問い合わせがあったクエリーが、クエリーの最適化によってクエリーの処理ツリーが作成されると、処理ツリー上の接点であるタスクをトポロジカルソートの順番で、他のタスクから依存がなく、直接的に処理できるタスクを見つけ、これらのタスクを、それぞれのタスクがアクセスするデータベースのリレーションをもとにグループに分ける。次に、グループ内のタスクをさらに共通部分式ごとにサブグループに集めて、それぞれのサブグループに対して、サブグループ内のタスクをもとに合成関係演算タスクを作成し、マルチオペレーション・プロセッシングを使用して、合成関係演算タスクを含むグループ内のタスクの処理を一度に行うものである。

合成関係演算タスクの処理結果は、サブグループ内の個々のタスクの処理結果のすべてを含んでいるために、サブグループ内のタスクは、合成関係演算タスクの処理結果として得られたリレーションを部分的に共有することになる。
合成関係演算タスクの処理結果を部分的に共有していることを示すために、サブグループ内の個々のタスクに対して格納位置による仮想リレーションを作成し、仮想リレーションに合成関係演算タスクの処理結果を共有するために必要な情報を記録しておく。
合成関係演算タスクが選択演算の場合には、選択条件に使用された属性で整列された処理結果であるリレーションを作成し、仮想リレーションとして、共有する合成関係演算タスクの処理結果のリレーション名、レコードの格納位置（レコードの行範囲、レコードが格納してあるブロックの番号とアドレス）などの情報を記録しておく。
合成関係演算タスクが射影演算の場合には、仮想リレーションとして、共有する合成関係演算タスクの処理結果のリレーション名、属性の格納位置(列番号)などの情報を記録しておく。
仮想リレーションにこれらの情報を記録しておくことによって、仮想リレーションを用いて処理を行うタスクは、合成関係演算タスクの処理結果の中から必要なレコードをすばやく取り出すことができるようになる。このように、合成関係演算を利用したマルチオペレーション・プロセッシングは、サブグループに集められたいくつかのタスクを１つの合成関係演算タスクに置き換えて処理を行い、サブグループ内の個々のタスクは、仮想リレーションを通して、合成関係演算タスクの処理結果のリレーションを部分的に共有することになる。このため、サブグループ内の個々のタスクの間で選択範囲及び／又は属性列の重なっているレコードを含んだ処理結果のリレーションをディスク上に別々に作成する必要がなくなり、ディスクをアクセスする回数を減らすことができるようになり、そのことによってクエリーの処理速度を向上させることが可能となる。

また、仮想リレーションのレコードに対してタスクが検索処理を行う場合は、仮想リレーションが部分的に共有する、合成関係演算タスクの処理結果として得られたリレーションの検索に使用する属性に対して、インデックスを作成しておく。そのことによって、共通の属性を用いて検索処理を行う他のタスクもインデックスを共有してレコードを検索することができるようになり、従来のハッシュ法を用いた結合演算処理のように、それぞれの結合演算タスクに対してメインメモリ内にハッシュテーブルを別々に作成する必要がなくなり、ディスクをアクセスする回数を減少させて、クエリーの処理速度を向上させることが可能となる。
さらに、仮想リレーションを用いて合成関係演算タスクの処理結果に対して処理を行うタスクは、仮想リレーションをもとにしてグループ分けをするのではなく、（仮想リレーションを包含している）合成関係演算タスクの処理結果として得られるリレーションをもとにグループ分けを行って、マルチオペレーション・プロセッシングを使用してこれらのタスク処理を一度に行うものとする。マルチオペレーション・プロセッシングを使用してこれらのタスク処理を一度に行うことによって、合成関係演算タスクの処理結果得られたリレーションは、何度もアクセスされることがなくなり、クエリーの処理速度を向上させることが可能となる。
以上に述べた方法を用いてクエリーからのタスク処理を行うことによって、合成関係演算を利用したマルチオペレーション・プロセッシングは、マルチオペレーション・プロセッシングだけを用いたタスク処理よりも、効率よくタスク処理を一度に行うことができるようになり、ディスクをアクセスする回数を減少させて、クエリーの処理速度を向上させることが可能となる。

以下で、図面を参照して、本発明の実施形態について詳しく説明する。
まず、本発明の合成関係演算を利用したマルチオペレーション・プロセッシングの概要を説明する。

［１．合成関係演算を利用したマルチオペレーション・プロセッシング］
合成関係演算を利用したマルチオペレーション・プロセッシングは、ユーザから問い合わせのあったクエリーがクエリーの最適化によって、関係代数で構成された処理ツリーに変換されると、処理ツリー上の接点であるタスクをトポロジカルソートの順番で、他のタスクから依存がなく、直接的に処理できるタスクを見つける。そして、これらのタスクを、それぞれのタスクがアクセスするデータベースのリレーションをもとにグループ分けを行い、さらにグループ内のタスクを共通部分式ごとにサブグループに集めて、それぞれのサブグループに対して、サブグループ内のタスクをもとに合成関係演算タスクを作成する。その後、マルチオペレーション・プロセッシングを使用して合成関係演算タスクを含むグループ内のタスクの処理を一度に行うものである。

［１−１．データベースシステムのアーキテクチャ］
図１は、本文で説明したクエリーの処理方法を用いたデータベースシステムのアーキテクチャの例である。ここで示した構成は、基本的に、上述した本発明者が出願した特願２００６−３５６４０６号の図１と同様のものである。
図１において、クエリーQ1〜Q6をユーザから問い合わせのあったクエリーとして扱い、データベースのアーキテクチャを説明していくことにする。クエリーQ1〜Q6は、クエリー・オプティマイザー（問い合わせ最適化処理）(900)によって最適化され、関係代数で構成された処理ツリーP₁〜P₆(902)に変換される。クエリー・プロセッサ(901)は、クエリー・オプティマイザー(900)とマルチオペレーション・プロセッサ（マルチオペレーション・プロセッシングを行うプロセッサ）(905)を制御している。
クエリーの一連の処理を行うクエリー・プロセッサ(901)は、処理ツリーP₁〜P₆からトポロジカルソートの順番で、他のタスクから依存がなく、直接的に処理できるタスクt₁ ¹，t₁ ³，t₁ ⁷，t₁ ⁹，t₂ ¹，t₂ ³，t₂ ⁴，t₃ ¹，t₃ ²，t₄ ¹，t₄ ²，t₅ ¹，t₅ ²，t₆ ¹，t₆ ³(903)を見つける。次に、クエリー・プロセッサは、これらの直接的に処理できるタスクをそれぞれのタスクがアクセスするデータベースのリレーションをもとにしてグループG1〜G4に分ける。タスクt₁ ³，t₂ ¹，t₃ ²，t₄ ¹，t₅ ¹，t₆ ³をグループG1に集め、タスクt₁ ¹，t₂ ³，t₃ ¹，t₆ ¹をグループG2に集め、タスクt₁ ⁷，t₂ ⁴をグループG3に集め、タスクt₁ ⁹，t₄ ²，t₅ ²をグループG4に集める。

グループにタスクを集めると、クエリー・プロセッサは、共通部分式を持つタスクをさらにサブグループに集める。タスクt₁ ³，t₃ ²，t₆ ³をサブグループSG1_G1集め、タスクt₄ ¹，t₅ ¹をサブグループSG2_G1に集め、タスクt₂ ³，t₃ ¹をサブグループSG1_G2に集め、タスクt₁ ⁷，t₂ ⁴をサブグループSG1_G3に集めることになる。クエリー・プロセッサは、サブグループにタスクを集めると、サブグループに対して合成関係演算タスクを作成する。
サブグループSG1_G1に対して合成関係演算タスクt_G1 ^SG1を作成し、サブグループSG2_G1に対して合成関係演算タスクt_G1 ^SG2を作成し、サブグループSG1_G2に対して合成関係演算タスクt_G2 ^SG1を作成し、サブグループSG1_G3に対して合成関係演算タスクt_G3 ^SG1を作成する。合成関係演算タスクを作成すると、クエリー・プロセッサは、グループG1〜G4をグループ列（キュー）(904)に挿入する。

グループの処理を行うマルチオペレーション・プロセッサ(905)は、利用できるプロセスの数（ここでは例として４つのプロセスを用意している）にしたがって、グループ列（キュー）からグループG1〜G4を取り出し、用意しているそれぞれのプロセスにマルチオペレーション・プロセッシングを使用してグループの処理を行わせる。ここでは、プロセス１がグループG1の処理を行い、プロセス２がグループG2の処理を行い、プロセス３がグループG3の処理を行い、プロセス４はグループG4の処理を行うことにする。これらのプロセスの処理は、オペレーティングシステム（ＯＳ）のプロセスのスケジューリングによって同時に処理されることになる。また、データベースサーバーに複数のＣＰＵ(907)を備えているならば、それぞれのプロセスによるグループの処理は、別々のＣＰＵ上で並列に処理されることになる。

まず、プロセス１が、グループG1内の合成関係演算タスクt_G1 ^SG1，t_G1 ^SG2、及びサブグループに集まらないタスクt₂ ¹の処理を、t₂ ¹，t_G1 ^SG1，t_G1 ^SG2の順番で終了すると、クエリー・プロセッサは、新たに処理できるタスクを処理ツリー(902)から検索する。タスクt₂ ¹が終了すると、新たにタスクt₂ ²の処理を始めることができるようになり、クエリー・プロセッサは、新たにグループG5を作成してグループG5にタスクt₂ ²を加えて、グループG5をグループ列（キュー）(904)に挿入する。次にタスクt_G1 ^SG1の処理が終了すると、新たにタスクt₁ ⁴，t₃ ³，t₆ ⁴の処理ができるようになり、クエリー・プロセッサは、新たにグループG6を作成してグループG6にタスクt₁ ⁴，t₃ ³，t₆ ⁴を加えて、グループG6をグループ列（キュー）(904)に挿入する。最後にタスクt_G1 ^SG2の処理が終了すると、新たに処理できるタスクは見出されないのでグループは作成されない。グループG1の処理が終了すると、プロセス１以外のすべてのプロセスは、他のグループの処理を行っているので、続けてプロセス１がグループ列からグループG5を取り出して、グループG5の処理を始めることになる。
他のプロセス２〜４もそれぞれ、グループ列からグループを取り出し、並列に処理を行う。

このようにして、それぞれのプロセスがグループの処理を終了するにつれて、次々にグループ列(904)からグループを取り出して、グループ内のタスク処理を行うことになり、マルチオペレーション・プロセッサ(905)は、グループの処理を繰り返して行っていくうちに、処理ツリー(902)内のタスクが次第に終了に近づき、処理ツリー内すべてのタスク処理が終了すると、与えられたすべてのクエリー処理は終了したことになる。また、クエリー・プロセッサ(901)が現在クエリーの処理（Q1からQ6までのクエリー）を行っている最中に、ユーザからの新たな問い合わせのクエリーQ7(909)があった場合には、クエリー・プロセッサは、クエリー・オプティマイザーを用いて新しいクエリーQ7に対する最適化を行って処理ツリーP₇を作成し、処理ツリーP₇からトポロジカルソートの順番で、処理できるタスクを見出し、それらのタスクと共通のリレーションをアクセスするタスクを集めたグループがグループ列に存在するかどうかを調べる。そのようなグループが既存のグループの中に存在するならば、そのグループにタスクを加えることになり、既存のグループに存在しない場合には、新たにグループを作成してそのグループにタスクを加えることにする。さらに、問い合わせのクエリーの数が増えると、プロセスがグループの処理を行っている間に、グループ列にいくつかのグループが待機するようになり、その間に数多くのタスクがグループに集められ、グループに集められたタスクが、さらにサブグループに集められて、数多くのタスク処理が一度に行われるようになる。このようにしてクエリーの処理を行うデータベースシステムは、数多くのクエリーを効率よく高速に行っていくものである。

［１−２．合成関係演算を利用したマルチオペレーション・プロセッシングを用いたクエリー・プロセッサのフローチャート］
図２は、合成関係演算を利用したマルチオペレーション・プロセッシングを用いてクエリーが処理される一連の流れを説明するためのフローチャートである。
まず、ＳＱＬなどのリレーショナルデータベースの言語を使用して、ユーザからデータベースサーバーにクエリーの問い合わせが入力される(S110)。問い合わせのあったＳＱＬの構文は、クエリー・オプティマイザー(900)によるクエリーの最適化処理によって関係演算で構成された処理ツリーに変換される(S120)。クエリー・プロセッサ(901)は、トポロジカルソートの順番で、直接的に処理することのできるタスクを見つける(S130)。直接的に処理することのできるタスクを見つけると、これらのタスクがアクセスするリレーションと共通のリレーションをアクセスするタスクが集められたグループがグループ列に存在するかどうかを調べる(S140)。共通のリレーションをアクセスするタスクが集められたグループがグループ列に存在しているならば、そのグループにタスクを加える(S150)。存在していない場合は、タスクのために新たなグループを作成し、そのグループにタスクを加えて、そのグループをグループ列に挿入する(S160)。
ここまでの処理は、前述した本発明者による特願２００６−３５６４０６号に記載したものと同じである。

グループにタスクを集めると、グループ内のタスクで共通部分式を持つタスクは、さらにサブグループに集める(S170)。サブグループにタスクを集めると、グループ内のサブグループに対して、サブグループ内のタスクをもとに合成関係演算タスクを作成する(S180)。
マルチオペレーション・プロセッサ(905)は、利用できるプロセスの数だけグループ列からグループを取り出し、マルチオペレーション・プロセッシングを用いて、グループ内の合成関係演算タスク、及びサブグループに集まらないタスクの処理を一度に行う(S190)。グループ内の合成関係演算タスクの処理が終了すると、サブグループ内のタスクに対して仮想リレーションを作成して合成関係演算タスクの処理結果内のレコードを部分的に共有できるようにする(S200)。

グループ内のタスク処理が終了すると、処理ツリー内のすべてのタスク処理が終了したかどうかを調べる(S210)。処理ツリー内にまだタスクが残っている場合は、繰り返して次に処理できるタスクを処理ツリーから見出していくことになる。
処理ツリー内のすべてのタスク処理が終了するとその処理ツリーに対応したクエリーの処理が終了する。

［１−３．合成関係演算を利用したマルチオペレーション・プロセッシングのアルゴリズム］
合成関係演算を利用したマルチオペレーション・プロセッシングを使用してグループに集められたタスクを一度に処理を行うに当たって、合成関係演算を利用したマルチオペレーション・プロセッシングのアルゴリズムをステップ１からステップ３に分けて、さらに説明する。

［（ａ）ステップ１：タスクのサブグループ化］
共通のリレーションRに対してグループ内のタスクの処理を行うに当たって、次のようにタスク間の共通部分式に関する定義を定めて、グループ内のタスクを共通部分式ごとにサブグループに集める(S170)。
・共通部分式に関する定義：
次に示す選択演算，射影演算，及びその他の演算に関する条件を満たすならば、タスクt_iとタスクt_jは共通部分式をもっている。
・選択演算：
タスクt_iは、リレーションRに対して属性A₁,A₂,A₃,…,A_kに関する選択条件(ＡＮＤ，ＯRで結合したもの)を使用する選択演算タスクであり、タスクt_jは、同一のリレーションRに対して同一の属性A₁,A₂,A₃,…,A_kに関する選択条件(ＡＮＤ，ＯＲで結合したもの)を使用する選択演算タスクであるときに、タスクt_iとタスクt_jが使用する選択条件において、１つの属性A_i(1≦i≦k)に関する選択条件だけは異なった条件かまたは同じ条件であり、A_i以外の属性に関する選択条件はまったく同じ条件である。
・射影演算：
タスクt_iは、リレーションRに対する射影演算タスクであり、タスクt_jは、同一のリレーションRに対する射影演算タスクである。
・その他の関係演算：
t_iとt_jは、同一の関係演算のタスク（t_i≡t_j)である。
以上の定義の条件に用いた演算は、あくまでも共通部分式に関するものである。

［（ｂ）ステップ２：合成関係演算タスクの作成］
ステップ１によってグループ内のタスクを共通部分式ごとにサブグループに集めると、サブグループ内のタスクの演算の種類に応じて、下記の方法を使用して、グループ内の各サブグループに対して、合成関係演算タスクを作成する(S180)。

・合成選択演算タスク作成方法：
サブグループ内の選択演算タスクTEMP_T1←σ_{<selection condition 1>}R，TEMP_T2←σ_{<selection condition 2>}R，TEMP_T3←σ_{<selection condition 3>}R，…，TEMP_Tn←σ_{<selection condition n>}Rに使われている選択条件<selection condition i>(i=1,2,…,n)を、ブール演算のＯＲを使用して接続し、接続した選択条件から選択範囲の重複した部分を取り除くために、次のような最適化を行って１つの合成選択演算タスクを作成する。
TEMP_SG←σ_{optimize(<selection condition 1> OR <selection condition 2> OR <selection condition 3> …OR <selection condition n>)}R
ここで、σ_{<selection condition i>}R (i=1,2,…,n)は、リレーションRに対して選択条件<selection condition i>にもとづいて選択演算することを意味し、σ_{optimize(…)}は、最適化により選択演算を行うことを意味する。また、TEMP_Ti←σ_{<selection condition i>}Rは、リレーションRに対して、選択条件<selection condition i>にしたがって選択(σ)するタスクを表し、その処理結果をTEMP_Tiに記録するものとする。

・合成射影演算タスク作成方法：
サブグループ内の射影演算タスクTEMP_T1←π_{<attribute list 1>}R，TEMP_T2←π_{<attribute list 2>}R，TEMP_T3←π_{<attribute list 3>}R ,…，TEMP_Tn←π_{<attribute list n>}Rに使われている属性のリスト<attribute list i>(i＝1,2,…,n)を集合Siに変換し、和集合（Union）を用いて各タスクからの属性を１つの集合TS＝S1∪S2∪S3∪…∪Snに集める。そして属性の集合TSを属性のリスト<attribute list SG>に変換して、合成射影演算タスクTEMP_SG←π_{<attribute list SG>}Rを作成する。ここで、π_{<attribute list i>}R(i=1,2,…,n)は、リレーションRに対して、属性のリスト<attribute list i>にもとづき射影演算を行うことを意味する。また、TEMP_Ti←π_{<attribute list i>}R(i=1,2,…,n)はリレーションRに対して属性<attribute list i>にもとづいて射影演算を行った結果をTEMP_Tiに記録することを表すものとする。

・その他の合成関係演算タスク作成方法：
サブグループには、同一の関係演算のタスクが集められているので、サブグループ内のタスクの１つを合成関係演算タスクとして使うものとする。

［（ｃ）ステップ３：マルチオペレーション・プロセッシングを使ったグループの処理］
ステップ２を用いてグループ内の各サブグループに関して作成された合成関係演算タスク及びグループ内でサブグループに集められないタスクに対してマルチオペレーション・プロセッシングを使用して処理を行う(S190)。
このマルチオペレーション・プロセッシングとして、ダイナミックマルチオペレーション・プロセッシングとスタティックマルチオペレーション・プロセッシングの２つの処理方法を提案してきた（特願２００６−３５６４０６号参照）が、この実施形態では、スタティック・マルチオペレーション・プロセッシングをマルチオペレーション・プロセッシングとして用いて処理を行っていくことにする。スタティック・マルチオペレーション・プロセッシングを使って処理を行う場合は、グループ内の合成関係演算タスク及びグループ内でサブグループに集まらないタスクに対してアクセスプランを作成し、アクセスプランから各タスクの処理コストをもとめ、処理コストの小さいタスクから処理コストの大きいタスクへと順番に処理するために、アクセスするリレーション内のブロックの順位を決定し、その順位にしたがってディスク内のブロックをアクセスし、このブロックを共通ブロックとして、このブロック上で処理を行う必要のあるグループ内のタスク処理を一度に処理していくことになる。

この方法は、アクセスすべきブロック（共通ブロック）の順位に従って、和集合、積集合及び差集合などの集合論を用いて、クエリーに含まれる各タスクの処理をきわめて論理的に行うものである。

［（ｄ）仮想リレーション］
合成関係演算を利用したマルチオペレーション・プロセッシングによって処理された合成関係演算タスクの処理結果は、サブグループ内の個々のタスクの処理結果のすべてを含んでいるために、サブグループ内のタスクは、合成関係演算タスクの処理結果を部分的に共有することになる。
合成関係演算タスクの処理結果を部分的に共有していることを示すために、サブグループ内の個々のタスクに対して仮想リレーションを作成し、仮想リレーションに合成関係演算タスクの処理結果を共有するために必要な情報を記録しておく。
合成関係演算タスクが選択演算の場合、選択条件に使われた属性で整列された処理結果のリレーションを作成し、仮想リレーションとして、共有する合成関係演算の処理結果のリレーション名、レコードの格納位置（レコードの行範囲、レコードが格納してあるブロックの番号とアドレス）などの情報を記録しておくことになる。
また、合成関係演算タスクが射影演算の場合、仮想リレーションとして、共有する処理結果のリレーション名、属性の格納位置(列番号)などの情報を記録しておくことになる。
仮想リレーションにこれらの情報を記録しておくことによって、仮想リレーションを用いて処理を行うタスクは、合成関係演算タスクの処理結果の中から必要なレコードをすばやく取り出すことができるようになる(S200)。

このようにして、サブグループに集められたいくつものタスクを１つの合成関係演算タスクに置き換えて処理を行い、サブグループ内の個々のタスクは仮想リレーションを通して合成関係演算タスクの処理結果を部分的に共有することになり、サブグループ内の個々のタスクの間で選択範囲、及び属性（列）の重なっているレコードを含んだ処理結果のリレーションをディスク上に別々に作成する必要がなくなるので、ディスクをアクセスする回数を減らすことができ、クエリーの処理速度を向上させることが可能となる。
また、仮想リレーションを用いて処理を行うタスクは、仮想リレーションをもとにしてグループ分けするのではなく、（仮想リレーションを包含している）合成関係演算タスクの処理結果として得られたリレーションをもとにグループ分けを行い、マルチオペレーション・プロセッシングを使用してこれらのタスク処理を一度に行うものとする。マルチオペレーション・プロセッシングを使用してこれらのタスク処理を一度に行うことによって、合成関係演算タスクの処理結果得られたリレーションのブロックは、何度もアクセスされることがなくなり、クエリーの処理速度を向上させることが可能となる。

以上のようにして、合成関係演算を利用したマルチオペレーション・プロセッシングを用いたクエリー処理を行うことによって、マルチオペレーション・プロセッシングだけを用いたクエリー処理よりも数多くのタスク処理が一度に行うことができるようになり、ディスクをアクセスする回数を減少させ、クエリーの処理速度を向上させることができる。

［２．合成関係演算を利用したマルチオペレーション・プロセッシングの具体例］
ここでは、上述で説明した合成関係演算を利用したマルチオペレーション・プロセッシングを、図３−１〜図３−３に示したデータ構造を有するデータベースに対するクエリーQ₁〜Q₅の例を用いて説明する。

［２−１．リレーションとクエリー（問い合わせ）処理］
［（ａ）リレーションの例］
図３−１〜図３−３には、リレーションDEPARTMENT，EMPLOYEE，WORKS_ON，PROJECTから構成されているデータベースを示している。
リレーションDEPARTMENT（図３−１（ａ）参照）には２５件のレコードが５つのブロックに格納してあり、それぞれのブロックには５件のレコードが存在しており、各ブロックは、次のブロックに対してブロックポインタを持っている。リレーションDEPARTMENTの主属性DNUMBERには、主インデックス(100)が存在し、主インデックスは、各ブロックに対してインデックスポインタを持っている。リレーションDEPARTMENTの属性DPHONEには、２次インデックス(102)が存在し、２次インデックスはリレーションDEPARTMENT内の各レコードに対してインデックスポインタを持っている。
リレーションEMPLOYEE（図３−２参照）には、２０件のレコードが５つのブロックに格納してあり、それぞれのブロックには４件レコードが存在しており、各ブロックは次のブロックに対してブロックポインタを持っている。リレーションEMPLOYEEの主属性SSNには、主インデックス(104)が存在し、主インデックスは各ブロックに対してインデックスのポインタを持っている。

リレーションPROJECT（図３−３（ｃ）参照）には、１０件のレコードが２つのブロックに格納してあり、それぞれのブロックには５件レコードが存在しており、各ブロックは、次のブロックに対してブロックポインタを持っている。リレーションPROJECTの主属性PNUMBERには、主インデックス(106)が存在し、主インデックスは、各ブロックに対してインデックスのポインタを持っている。
リレーションWORKS_ON（図３−３（ｄ）参照）には、２５件のレコードが５つのブロックに格納してあり、それぞれのブロックには５件のレコードが存在する。各ブロックは、次のブロックに対してブロックポインタを持っている。リレーションWORKS_ONの主属性ESSN，PNOは、リレーションEMPLOYEE，PROJECTに対する外部キーである。以上をまとめると次のような表になる。

［（ｂ）クエリー例］
次に、図３−１〜図３−３に示したデータベースをもとにして合成関係演算を利用したマルチオペレーション・プロセッシングを説明するために、下記に示すようなクエリーQ₁，Q₂，Q₃，Q₄，Q₅，Q₆処理を取り上げることにする。図３−１〜図３−３のデータベースに対して、次のような６つのクエリーQ₁，Q₂，Q₃，Q₄，Q₅，Q₆の問い合わせがあったとする。

（Q1）SELECT LNAME,DNUMBER,DNAME,PNUMBER,PNAME
FROM DEPARTMENT,EMPLOYEE,PROJECT,WORKS_ON
WHERE DPHONE=23-3732 AND DNUMBER=DNUM AND
BDATE<'DEC-31-1961' AND SSN=ESSN AND
PNAME='Aquarius' AND PLOCATION='New York' AND PNUMBER=PNO;

（Q2）SELECT DNAME,DNUMBER,PNAME,PNUMBER,SSN,LNAME,BDATE
FROM EMPLOYEE,DEPARTMENT,PROJECT
WHERE SSN=164545566 AND SSN=MGRSSN AND
PNAME='Stafford' AND PLOCATION='New York' AND DNUMBER=DNUM;

（Q3）SELECT SSN,FNAME,LNAME,DNAME,DNUMBER
FROM DEPARTMENT,EMPLOYEE
WHERE DNUMBER=DNUM AND BDATE>'JAN-1-1971';

（Q4）SELECT *
FROM PROJECT,DEPARTMENT,EMPLOYEE
WHERE DNUMBER=DNUM AND PNUMBER=PNO AND SSN=ESSN;

（Q5）SELECT *
FROM DEPARTMENT,EMPLOYEE,WORKS_ON
WHERE DNUMBER=DNUM AND SSN=ESSN AND HOURS<10;

（Q6）SELECT FNAME,LNAME,DNUMBER,DNAME
FROM DEPARTMENT,EMPLOYEE
WHERE DNUMBER=7 AND DNUMBER=DNUM AND
BDATE>'FEB-11-1959' AND BDATE<'NOV-21-1966';

［２−２．処理プランの作成］
クエリー・プロセッサは、問い合わせのあった各クエリーQ₁，Q₂，Q₃，Q₄，Q₅，Q₆に対して、クエリーの最適化を行い、各クエリーを処理していくための最良な処理方法である下記の処理プランを作成していくことになる。クエリーQ₁に対して処理プランP₁を作成し、クエリーQ₂に対して処理プランP₂を作成し、クエリーQ₃に対して処理プランP₃を作成し、クエリーQ₄に対して処理プランP₄を作成し、クエリーQ₅に対して処理プランP₅を作成し、クエリーQ₆に対して処理プランP₆を作成する。

作成した処理プランを処理ツリーで表すと、図４−１〜図４−３に示したようにP₁〜P₆となる。
処理ツリーP_i内のタスクt_i ^j（iは処理ツリーの番号、jはそれぞれの処理ツリー内の処理番号を表わしている）は、以下に示すように、
（t_i ^j）：処理結果←関係代数
として表し、処理結果は関係代数を処理した結果を表すものとする。処理結果名がTEMP_Tj_iの場合は、処理ツリーP_i内のタスクt_i ^jの処理結果(処理ツリーの中間結果)を表し、処理結果がRESULT_Q_iの場合は、処理ツリーP_iの処理結果であることを表している。関係代数は、データベースのリレーションに対して、直接的に処理を行う演算であり、選択演算(σ)、射影演算(π)、結合演算(|X|)などの演算である。

処理プランP₁
(t₁ ¹)： TEMP_T1_1←σ_{DPHONE=23-3732}DEPARTMENT
(t₁ ²)： TEMP_T2_1←π_{DNUMBER,DNAME}TEMP_T1_1
(t₁ ³)： TEMP_T3_1←σ_{BDATE<'DEC-31-1961'}EMPLOYEE
(t₁ ⁴)： TEMP_T4_1←π_{SSN,LNAME,DNUM}TEMP_T3_1
(t₁ ⁵)： TEMP_T5_1←TEMP_T2_1 |X|_DNUMBER=DNUMTEMP_T4_1
(t₁ ⁶)： TEMP_T6_1←π_{SSN,LNAME,DNUMBER,DNAME}TEMP_T5_1
(t₁ ⁷)： TEMP_T7_1←σ_{PNAME='Aquarius” AND PLOCATION='New York'}PROJECT
(t₁ ⁸)： TEMP_T8_1←π_{PNUMBER,PNAME}TEMP_T7_1
(t₁ ⁹)： TEMP_T9_1←π_ESSN,PNOWORKS_ON
(t₁ ¹⁰)：TEMP_T10_1←TEMP_T8_1 |X|_PNUMBER=PNOTEMP_T9_1
(t₁ ¹¹)：TEMP_T11_1←π_{ESSN,PNUMBER,PNAME}TEMP_T10_1
(t₁ ¹²)：TEMP_T12_1←TEMP_T6_1 |X|_SSN=ESSNTEMP_T11_1
(t₁ ¹³)： RESULT_Q1←π_{LNAME,DNUMBER,DNAME,PNUMBER,PNAME}TEMP_T12_1

処理プランP₂
(t₂ ¹)：TEMP_T1_2←σ_{SSN=164545566}EMPLOYEE
(t₂ ²)：TEMP_T2_2←π_{SSN,LNAME,BDATE}TEMP_T1_2
(t₂ ³)：TEMP_T3_2←π_{DNUMBER,DNAME,MGRSSN}DEPARTMENT
(t₂ ⁴)：TEMP_T4_2←σ_{PNAME='Stafford' AND PLOCATION='New York'}PROJECT
(t₂ ⁵)：TEMP_T5_2←π_{PNUMBER,PNAME,DNUM}TEMP_T4_2
(t₂ ⁶)：TEMP_T6_2←TEMP_T3_2 |X|_DNUMBER=DNUMTEMP_T5_2
(t₂ ⁷)：TEMP_T7_2←π_{DNUMBER,DNAME,MGRSSN,PNUMBER,PNAME}TEMP_T6_2
(t₂ ⁸)：TEMP_T8_2←TEMP_T2_2 |X|_SSN=MGRSSNTEMP_T7_2
(t₂ ⁹)：RESULT_Q2←π_{DNAME,DNUMBER,PNAME,PNUMBER,SSN,LNAME,BDATE}TEMP_T8_2

処理プランP₃
(t₃ ¹)：TEMP_T1_3←π_{DNUMBER,DNAME}DEPARTMENT
(t₃ ²)：TEMP_T2_3←σ_{BDATE>'JAN-1-1971'}EMPLOYEE
(t₃ ³)：TEMP_T3_3←π_{SSN,FNAME,LNAME,DNUM}TEMP_T2_3
(t₃ ⁴)：TEMP_T4_3←TEMP_T1_3 |X|_DNUMBER=DNUMTEMP_T3_3
(t₃ ⁵)：RESULT_Q3←π_{SSN,FNAME,LNAME,DNAME,DNUMBER}TEMP_T4_3

処理プランP₄
(t₄ ¹)：TEMP_T1_4←DEPARTMENT |X|_DNUMBER=DNUMEMPLOYEE
(t₄ ²)：TEMP_T2_4←PROJECT |X|_PNUMBER=PNOWORKS_ON
(t₄ ³)：RESULT_Q4←TEMP_T1_4 |X|_SSN=ESSNTEMP_T2_4

処理プランP₅
(t₅ ¹)：TEMP_T1_5←DEPARTMENT |X|_DNUMBER=DNUMEMPLOYEE
(t₅ ²)：TEMP_T2_5←σ_HOURS<10WORKS_ON
(t₅ ³)：RESULT_Q5←TEMP_T1_5 |X|_SSN=ESSNTEMP_T2_5

処理プランP₆
(t₆ ¹)：TEMP_T1_6←σ_DNUMBER=7DEPARTMENT
(t₆ ²)：TEMP_T2_6←π_{DNUMBER,DNAME}TEMP_T1_6
(t₆ ³)：TEMP_T3_6←σ_{BDATE>'FEB-11-1959' AND BDATE < NOV-21-1966'}EMPLOYEE
(t₆ ⁴)：TEMP_T4_6←π_{FNAME,LNAME,DNUM}TEMP_T3_6
(t₆ ⁵)：TEMP_T5_6←TEMP_T2_6 |X|_DNUMBER=DNUMTEMP_T4_6
(t₆ ⁶)：RESULT_Q6←π_{FNAME,LNAME,DNUMBER,DNAME}TEMP_T5_6

［２−３．タスクのグループ化とサブグループ化］
［（ａ）タスクのグループ化］
合成関係演算を利用したマルチオペレーション・プロセッシングを適用するにあたって、図４−１〜図４−３に示した処理プランP₁，P₂，P₃，P₄，P₅，P₆にもとづいて作成された処理ツリーからトポロジカルソートの順番で、他のタスクから依存がなく直接的に処理できるタスクt₁ ¹，t₁ ³，t₁ ⁷，t₁ ⁹，t₂ ¹，t₂ ³，t₂ ⁴，t₃ ¹，t₃ ²，t₄ ¹，t₄ ²，t₅ ¹，t₅ ²，t₆ ¹，t₆ ³を見つけて、各タスクがアクセスするデータベースのリレーションをもとにグループに分けていくと、次のようにグループ分けすることになる。

また、２つのリレーションをアクセスする結合演算タスクなどの場合は、検索先のリレーションではなく検索元のリレーションをもとにしてグループ分けを行う。
EMPLOYEE： グループ G1＝{t₁ ³,t₂ ¹,t₃ ²,t₄ ¹,t₅ ¹,t₆ ³}
DEPARTMENT：グループ G2＝{t₁ ¹,t₂ ³,t₃ ¹,t₆ ¹}
PROJECT： グループ G3＝{t₁ ⁷,t₂ ⁴}
WORKS_ON： グループ G4＝{t₁ ⁹,t₄ ²,t₅ ²}

グループG1には、リレーションEMPLOYEEをアクセスするタスクが集められ、グループG2には、リレーションDEPARTMENTをアクセスするタスクが集められ、グループG3にはリレーションPROJECTをアクセスするタスクが集められる。そしてグループG4にはリレーションWORKS_ONをアクセスするタスクが集められてグループ分けが行われる。

［（ｂ）タスクのサブグループ化］
グループG1，G2，G3，G4にタスクが分けられると、グループ内のタスクで共通部分式を持っているタスクは、次のようにさらに共通部分式ごとにサブグループSG1_G1，SG2_G1，SG1_G2，SG1_G3に分けていくことになる。

EMPLOYEE： グループ G1 ＝{SG1_G1,SG2_G1,t₂ ¹}
サブグループ SG1_G1＝{t₁ ³,t₃ ²,t₆ ³}
サブグループ SG2_G1＝{t₄ ¹,t₅ ¹}
DEPARTMENT： グループ G2 ＝{SG1_G2,t₁ ¹,t₆ ¹}
サブグループ SG1_G2＝{t₂ ³,t₃ ¹}
PROJECT： グループ G3 ＝{SG1_G3}
サブグループ SG1_G3＝{t₁ ⁷,t₂ ⁴}
WORKS_ON： グループ G4 ＝{t₁ ⁹,t₄ ²,t₅ ²}

サブグループSG1_G1はリレーションEMPLOYEEに対して共通部分式の定義で述べた属性BDATEを選択条件に使用する選択演算タスクが集められたサブグループである。
サブグループSG2_G1はリレーションEMPLOYEEに対して共通部分式の定義で述べた同一の関係演算の処理を行うタスクが集められたサブグループである。
サブグループSG1_G2はリレーションDEPARTMENTに対して共通部分式の定義で述べた射影演算の処理を行うタスクのサブグループである。
サブグループSG1_G3はリレーションPROJECTに対して共通部分式の定義で述べた属性PNAME,PLOCATIONを選択条件に使用する選択演算タスクが集められたサブグループであり、これらのタスクが使用する選択条件において、属性PNAMEに関する選択条件は異なっているが、それ以外の属性PLOCATIONに関する選択条件は全く同じ条件である。
グループG4内のタスクt₁ ⁹，t₄ ²，t₅ ²は共通部分式を持っていないので、グループG4にサブグループは作成されないことになる。

図５は、処理ツリーからトポロジカルソートの順番で直接的に処理できるタスクt₁ ¹，t₁ ³，t₁ ⁷，t₁ ⁹，t₂ ¹，t₂ ³，t₂ ⁴，t₃ ¹，t₃ ²，t₄ ¹，t₄ ²，t₅ ¹，t₅ ²，t₆ ¹，t₆ ³(300)を、それぞれのタスクがアクセスするデータベースのリレーションをもとにグループG1，G2，G3，G4に分け、さらにグループ内のタスクで共通部分式を持っているタスクを共通部分式ごとにサブグループSG1_G1，SG2_G1，SG1_G2，SG1_G3に分けている様子を表わしている。

［（ｃ）合成関係演算タスクの作成］
グループ内にサブグループが作成されると、作成されたサブグループSG1_G1，SG2_G1，SG1_G2，SG1_G3に対して次のように合成関係演算タスクt_G1 ^SG1，t_G1 ^SG2，t_G2 ^SG1，t_G3 ^SG1を作成することができる。
(t_G1 ^SG1)：TEMP_SG1_G1←σ_{BDATE<'NOV-21-1966' OR BDATE>'JAN-1-1971'}EMPLOYEE
(t_G1 ^SG2)：TEMP_SG2_G1←DEPARTMENT |X|_DNUMBER=DNUMEMPLOYEE
(t_G2 ^SG1)：TEMP_SG1_G2←π_{DNUMBER,DNAME,MGRSSN}DEPARTMENT
(t_G3 ^SG1)：TEMP_SG1_G3←σ_{PLOCATION='New York' AND (PNAME='Aquarius” OR PNAME='Stafford')}PROJECT

以上のように得られた合成関係演算タスクを説明すると、以下のようになる。
タスクt_G1 ^SG1は、下記に示すようにサブグループSG1_G1内の選択演算タスクt₁ ³，t₃ ²，t₆ ³の選択条件をブール演算のORを用いて接続して１つの選択条件<temp_cond>を作成し、接続した選択条件から選択範囲の重複した部分を取り除くために、簡潔化し最適化Optimize(<temp_cond>)した選択条件を作成し、その選択条件を用いた合成選択演算タスクである。
<temp_cond>＝(BDATE<'DEC-31-1961') OR (BDATE>'JAN-1-1971') OR
(BDATE>'FEB-11-1959' AND BDATE<'NOV-21-1966')
Optimize(<temp_cond>) ⇒ BDATE<'NOV-21-1966' OR BDATE>'JAN-1-1971'
Optimize(<temp_cond>)によって表わされる選択条件は、ブール演算のＯＲを用いて作成した選択条件<temp_cond>を最適化するために、それぞれの選択条件の選択範囲の論理和（Union）を求めて、選択範囲の重複した部分を取り除いて新たに簡潔化された選択条件として得られたものである。

この最適化を、上述のタスクt_G1 ^SG1の例で、図６を用いて詳しく説明する。
図６（ａ）は、ブール演算のＯＲを使用して接続しているタスクt₁ ³の選択条件BDATE<'DEC-31-1961'である生年月日の選択範囲、タスクt₆ ³の選択条件BDATE>'FEB-11-1959' AND BDATE<'NOV-21-1966'である生年月日の選択範囲、タスクt₃ ²の選択条件BDATE>'JAN-1-1971'の生年月日の選択範囲を、生年月日の値が小さいほうから順番に左から右に１つの水平な線上に表している。
次に、図６（ｂ）に示すように、タスクt₁ ³，t₃ ²，t₆ ³の選択条件に使われている生年月日の選択範囲の論理和（Union）を求めると、BDATEの値がNOV-21-1966以前とBDATEの値JAN-1-1971以降のBDATEの選択範囲のみが必要になることがわかる。
このようにして選択条件の選択範囲の論理和で求めた生年月日の選択範囲を新たな選択条件に直すと”BDATE<'NOV-21-1966' OR BDATE>'JAN-1-1971'”と簡潔化された選択条件になり、この選択条件を前述したように合成選択演算タスクt_G1 ^SG1の選択演算の選択条件として使用することになる。

タスクt_G1 ^SG2は、サブグループSG2_G1内のタスクが同一の結合演算（t₄ ¹≡t₅ ¹）なので、サブグループSG2_G1内の結合演算タスクの１つをそのまま合成関係演算タスクとして使用することになる。
タスクt_G2 ^SG1は、サブグループSG1_G2内の射影演算タスクt₂ ³，t₃ ¹に使われている属性を、和集合（Union）を使用して作成した合成射影演算タスクである。
タスクt_G3 ^SG1は、下記に示すようにサブグループSG1_G3内の選択演算タスクt₁ ⁷，t₂ ⁴の選択条件をブール演算のＯＲを用いて接続して１つの選択条件<temp_cond>を作成し、接続した選択条件から選択範囲の重複した部分を取り除くために最適化Optimize(<temp_cond>)を行って作成した合成選択演算タスクである。
<temp_cond>＝(PNAME='Aquarius' AND PLOCATION='New York') OR
(PNAME='Stafford' AND PLOCATION='New York')
Optimize(<temp_cond>) ⇒ PLOCATION='New York' AND (PNAME='Aquarius' OR PNAME='Stafford')

Optimize(<temp_cond>)は、ブール演算のＯＲを用いて作成した選択条件<temp_cond>を最適化するために、それぞれの選択条件の選択範囲の論理和(Union)を求めて、選択範囲の重複した部分であるPLOCATION='New York'を取り除いて新たに簡潔化された選択条件として得られたものである。

以上のように、グループ内のサブグループに対して合成関係演算タスクを作成すると、グループ内のサブグループを次のように合成関係演算タスクで置き換えることができる。
EMPLOYEE： グループ G1＝{t_G1 ^SG1,t_G1 ^SG2,t₂ ¹}
DEPARTMENT：グループ G2＝{t_G2 ^SG1,t₁ ¹,t₆ ¹}
PROJECT： グループ G3＝{t_G3 ^SG1}
WORKS_ON： グループ G4＝{t₁ ⁹,t₄ ²,t₅ ²}

［２−４．マルチオペレーション・プロセッシングによる合成関係演算タスク処理］
グループ内のサブグループが合成関係演算タスクで置き換えられると、マルチオペレーション・プロセッシングを適用して、グループ内の合成関係演算タスクを含むグループ内のタスクの処理を一度に行っていくことにする。マルチオペレーション・プロセッシングとして、スタティック・マルチオペレーション・プロセッシング（特願２００６−３５６４０６号参照）を使用して、グループG1，G2，G3，G4の処理を行っていく場合について記述する。

［（ａ）グループG1の処理］
スタティックマルチオペレーション・プロセッシングを使用してグループG1内の合成選択演算タスクt_G1 ^SG1，t_G1 ^SG2及びサブグループに集まらないタスクt₂ ¹の処理を一度に行うことにする。前述したように、グループG1内の各タスクは次のようなものである。
EMPLOYEE：グループ G1＝{t_G1 ^SG1,t_G1 ^SG2,t₂ ¹}
(t_G1 ^SG1)：TEMP_SG1_G1←σ_{BDATE<'NOV-21-1966' OR BDATE>'JAN-1-1971'}EMPLOYEE
(t_G1 ^SG2)：TEMP_SG2_G1←DEPARTMENT |X|_DNUMBER=DNUMEMPLOYEE
(t₂ ¹)： TEMP_T1_2←σ_{SSN=164545566}EMPLOYEE

［（ａ−１）各タスクのアクセスプラン］
まずグループG1内のタスクt_G1 ^SG1，t_G1 ^SG2，t₂ ¹に対して次のようなアクセスプランを作成する。
plan(t_G1 ^SG1)：EMPLOYEEを線形探索して選択処理を行う。
plan(t_G1 ^SG2)：EMPLOYEEをスキャンしてDEPARTMENTの主インデックスを使用して結合処理を行う。
plan(t₂ ¹)： EMPLOYEEの主インデックスを使った選択処理を行う。

［（ａ-２）各タスクの処理コスト］
各タスクに対してアクセスプランを作成した後に、アクセスプランをもとに各タスクの処理コストを計算すると、以下のようになる。
タスクt_G1 ^SG1の処理コスト：cost(t_G1 ^SG1)＝b＝5
タスクt_G1 ^SG2の処理コスト：cost(t_G1 ^SG2)＝b_E+(|EMPLOYEE|*(x_D+1))＝5+(20*(1+1))＝45
タスクt₂ ¹の処理コスト：cost(t₂ ¹)＝x_E+1＝2
処理コストとはタスクの処理を行うためにディスクをアクセスする回数である。ここではタスクの処理を行うためにディスクをアクセスする回数を減らすのが目的であるので、メインメモリで計算する時間、処理結果をディスクに保存するコストは省略することにする。また、cost()は、処理コストを表すものとする。

タスクt_G1 ^SG1の処理コストは、リレーションEMPLOYEEを線形探索し、５つのブロックをアクセスするので処理コストはb_E＝5である。
タスクt_G1 ^SG2の処理コストは、リレーションEMPLOYEEをスキャンする処理コストb_EとEMPLOYEE内の各レコードに対してリレーションDEPARTMENTの主インデックスを使用して結合できるレコードを検索する処理コスト|EMPLOYEE|*(x_D+1)を合計した処理コストである。
リレーションEMPLOYEEには、２０件のレコードが５つのブロックに格納してある。x_D+1は、B⁺ツリーインデックスなどマルチレベルのインデックスのレベルとブロックをアクセスする処理コストであり、図３−１のリレーションDEPARTMENTに存在する主インデックスのレベルx_Dは１であるので、タスクt_G1 ^SG2の処理コストは、b_E+(|EMPLOYEE|*(x_D+1))＝5+(20*(1+1))＝45である。
タスクt₂ ¹の処理コストは、主インデックスを使用して１つのレコードを検索する処理コストである。これは、リレーションのEMPLOYEEの主インデックスのレベルx_Eとブロックをアクセスする処理コストであり、図３−２のリレーションEMPLOYEEの主インデックスのレベルは１であるので、処理コストはx_E+1＝2である。

以上のようにタスクt_G1 ^SG1，t_G1 ^SG2，t₂ ¹に対して、処理コストを計算し、処理コストをもとに、これらのタスクを処理コストの小さい順番から並び替えると次のようになる。
sort(t_G1 ^SG1,t_G1 ^SG2,t₂ ¹) ⇒ (t₂ ¹,t_G1 ^SG1,t_G1 ^SG2)
sort(…)は並べ替えを表している。

［（ａ−３）各タスクに対応するブロックの集合］
タスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2を処理するにあたって、インデックスを用いてアクセスする必要のあるリレーションのすべてのブロックを事前に調べて、各タスクに対応するブロック集合B₂ ¹，B_G1 ^SG1，B_G1 ^SG2に集めると、次のようになる。
タスクt₂ ¹に対するブロック集合：B₂ ¹＝{b₂}
タスクt_G1 ^SG1に対するブロック集合：B_G1 ^SG1＝{b₁,b₂,b₃,b₄,b₅}
タスクt_G1 ^SG2に対するブロック集合：B_G1 ^SG2＝{b₁,b₂,b₃,b₄,b₅}
このように、各タスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2に対応するブロック集合B₂ ¹，B_G1 ^SG1，B_G1 ^SG2を見出すことができるのは、以下に示すような理由にもとづくからである。

タスクt₂ ¹は、選択条件”SSN=164545566”を満たすレコードが必要である。リレーションEMPLOYEEの主インデックスを使用すると、属性SSNの値が164545566であるレコードはブロックの相対アドレスが256であるブロックb₂に格納してあることがわかり、ブロックb₂だけをアクセスすることが必要となるので、タスクt₂ ¹の処理を行うためにアクセスする必要のあるブロックの集合は{b₂}となる。ブロックb₂の相対アドレスとはリレーションEMPLOYEEの最初のブロックアドレスをゼロとしたときに、そこから何バイト移動したところにブロックb₂が格納してあるかを表したものである。

タスクt_G1 ^SG1は、選択条件”BDATE<'NOV-21-1966' OR BDATE>'JAN-1-1971'”を満たすレコードが必要である。リレーションEMPLOYEEの属性BDATEにはインデックスが存在しないので、リレーションEMPLOYEE内のすべてのレコードを線形探索するために、リレーションEMPLOYEEの最初のブロックb₁から最後のブロックb₅までのブロックをアクセスすることが必要となるので、タスクt_G1 ^SG1の処理を行うためにアクセスする必要のあるブロックの集合は{b₁,b₂,b₃,b₄,b₅}となる。

タスクt_G1 ^SG2は、結合演算の処理を行うために、リレーションEMPLOYEEの最初のブロックb₁から最後のブロックb₅までのブロックをアクセスすることが必要となるので、タスクt_G1 ^SG2の処理を行うためにアクセスする必要のあるブロックの集合は{b₁,b₂,b₃,b₄,b₅}となる。

［（ａ−４）アクセスすべきブロック（共通ブロック）の順位の決定］
以上のように、各タスクに対応するブロック集合を見出した後に、処理コストの小さいタスクから処理コストの大きいタスクへと順番に、すなわちタスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2の順番に各タスクに対応するブロック集合の和集合を求めていくことにする。
まず、TB₀＝{}（空集合）として、TB₀とタスクt₂ ¹に対応するブロック集合B₂ ¹と和集合TB₂ ¹を求める。次に、このTB₂ ¹とタスクt_G1 ^SG1に対応するブロック集合B_G1 ^SG1の和集合TB_G1 ^SG1を求める。さらに、このTB_G1 ^SG1とタスクt_G1 ^SG2に対応するブロック集合B_G1 ^SG2との和集合TB_G1 ^SG2を求めると次のようになる。この場合、和集合を求めるに当たっては、新たに加える集合は和集合の中で最後に加えていくものとする。
TB₀＝{}
タスクt₂ ¹に対応する集合B₂ ¹との和集合：TB₂ ¹＝TB₀∪B₂ ¹＝{b₂}
タスクt_G1 ^SG1に対応する集合B_G1 ^SG1との和集合：TB_G1 ^SG1＝TB₂ ¹∪B_G1 ^SG1＝{b₂,b₁,b₃,b₄,b₅}
タスクt_G1 ^SG2に対応する集合B_G1 ^SG2との和集合：TB_G1 ^SG2＝TB_G1 ^SG1∪B_G1 ^SG2＝{b₂,b₁,b₃,b₄,b₅}

以上のように、処理コストの小さいタスクに対応するブロック集合から処理コストの大きいタスクに対応するブロック集合へと順番に和集合を求めていくと、最後のタスク（処理コストの１番大きいタスク）に対応するブロック集合との和集合TB_G1 ^SG2から、ディスクのブロックb₂からアクセスを開始し、ブロックb₅でアクセスを終了すればよいことになり、ディスクにおけるリレーションEMPLOYEE内のブロックへのアクセスの順番を（b₂，b₁，b₃，b₄，b₅）のように決定することができる。このような方法で和集合を求めることは、処理コストの小さいタスクから順番に処理を行うに当たって、ディスク内のブロックをどのような順番でアクセスすればよいか、その順番を決定するためである。このようにして得られたブロックb₂，b₁，b₃，b₄，b₅は、タスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2を順番に処理していくときに共有され得るので、これらのブロックを共通ブロックと呼ぶことにする。

前述したブロック集合B₂ ¹，B_G1 ^SG1，B_G1 ^SG2の中に含まれているブロックを見ると、ブロックb₂は、タスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2を処理するために使用され、ブロックb₁は、タスクt_G1 ^SG1，t_G1 ^SG2を処理するために使用され、ブロックb₃，b₄，b₅は、タスクt_G1 ^SG1，t_G1 ^SG2を処理するために使用されることがわかる。これらのブロックを共通ブロックとして扱うことにすると、これらの共通ブロックを必要とするタスクを共通ブロック上で一度に処理することができる。以上のことをまとめると次のような表になる。

［（ａ−５）共通ブロックでのタスクの処理］
以上のように、それぞれの共通ブロックでどのようなタスクが処理されるかを見出すためには、タスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2に対して作成されたブロック集合B₂ ¹，B_G1 ^SG1，B_G1 ^SG2の情報にもとづいて、次に記述するような手順を用いればよい。
最初に、ブロックの相対アドレスが256であるブロックb₂をディスクからアクセスして、ブロックb₂内のデータをメインメモリに読み込み、グループ内のタスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2がブロックb₂で処理を行う必要があるかどうかを調べるため、ブロックb₂を集合{b₂}として表し、この{b₂}とブロックの集合B₂ ¹，B_G1 ^SG1，B_G1 ^SG2との間でそれぞれ積集合（Intersection）を求めると次のようになる。
タスクt₂ ¹に対して：B₂ ¹∩{b₂}＝{b₂}
タスクt_G1 ^SG1に対して：B_G1 ^SG1∩{b₂}＝{b₂}
タスクt_G1 ^SG2に対して：B_G1 ^SG2∩{b₂}＝{b₂}

タスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2に対する積集合が{b₂}となり、タスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2がメインメモリに読み込んだブロックb₂で処理を行う必要があることが明らかになり、ブロックb₂は共通ブロックとなり、共通ブロックb₂で各タスクの処理を行うことになる。共通ブロックであるブロックb₂でのタスクの処理が終了すると、ブロックb₂を再びアクセスする必要がなくなるので、ブロックb₂を取り除くために、集合B₂ ¹，B_G1 ^SG1，B_G1 ^SG2と集合{b₂}との差集合（Difference）を求める。得られた差集合の値をB₂ ¹⁽¹⁾，B_G1 ^SG1(1)，B_G1 ^SG2(1)とすると、次のようになる。
タスクt₂ ¹に対して：B₂ ¹−{b₂}＝{}＝B₂ ¹⁽¹⁾
タスクt_G1 ^SG1に対して：B_G1 ^SG1−{b₂}＝{b₁,b₃,b₄,b₅}＝B_G1 ^SG1(1)
タスクt_G1 ^SG2に対して：B_G1 ^SG2−{b₂}＝{b₁,b₃,b₄,b₅}＝B_G1 ^SG2(1)
この結果、集合B₂ ¹⁽¹⁾が空集合{}になりタスクt₂ ¹の処理が終了したことがわかる。

次に、ブロックの相対アドレスが0であるブロックb₁をディスクからアクセスして、ブロックb₁内のデータをメインメモリに読み込み、すでに処理の済んだタスクt₂ ¹を除くグループ内のタスクt_G1 ^SG1，t_G1 ^SG2がブロックb₁で処理を行う必要があるかどうかを調べるために、ブロックb₁を集合{b₁}として表し、{b₁}とブロックの集合B_G1 ^SG1(1)，B_G1 ^SG2(1)との間でそれぞれ積集合を求めると次のようになる。
タスクt_G1 ^SG1に対して：B_G1 ^SG1(1)∩{b₁}＝{b₁}
タスクt_G1 ^SG2に対して：B_G1 ^SG2(1)∩{b₁}＝{b₁}
タスクt_G1 ^SG1，t_G1 ^SG2に対する積集合が{b₁}となり、タスクt_G1 ^SG1，t_G1 ^SG2がメインメモリに読み込んだブロックb₁で処理を行うことが必要となり、ブロックb₁は共通ブロックとなり、共通ブロックb₁で各タスクの処理を行うことになる。共通ブロックであるブロックb₁でのタスクの処理が終了すると、ブロックb₁を再びアクセスする必要がなくなるので、集合B_G1 ^SG1(1)，B_G1 ^SG2(1)と集合{b₁}との差集合を求める。得られた差集合の値をB_G1 ^SG1(2)，B_G1 ^SG2(2)とすると、次のようになる。
タスクt_G1 ^SG1に対して：B_G1 ^SG1(1)−{b₁}＝{b₃,b₄,b₅}＝B_G1 ^SG1(2)
タスクt_G1 ^SG2に対して：B_G1 ^SG2(1)−{b₁}＝{b₃,b₄,b₅}＝B_G1 ^SG2(2)

次に、ブロックの相対アドレスが512であるブロックb₃をディスクからアクセスして、ブロックb₃内のデータをメインメモリに読み込み、すでに処理の済んだタスクt₂ ¹を除くグループ内のタスクt_G1 ^SG1，t_G1 ^SG2がブロックb₃で処理を行う必要があるかどうかを調べるために、ブロックb₃を集合{b₃}として表し、{b₃}とブロックの集合B_G1 ^SG1(2)，B_G1 ^SG2(2)との間で積集合を求めると次のようになる。
タスクt_G1 ^SG1に対して：B_G1 ^SG1(2)∩{b₃}＝{b₃}
タスクt_G1 ^SG2に対して：B_G1 ^SG2(2)∩{b₃}＝{b₃}
タスクt_G1 ^SG1，t_G1 ^SG2に対する積集合が{b₃}となり、タスクt_G1 ^SG1，t_G1 ^SG2がメインメモリに読み込んだブロックb₃で処理を行うことが必要となり、ブロックb₃は共通ブロックとなり、共通ブロックb₃でタスクt_G1 ^SG1，t_G1 ^SG2の処理を行うことになる。共通ブロックであるブロックb₃でのタスクの処理が終了すると、ブロックb₃を再びアクセスする必要がなくなるので、集合B_G1 ^SG1(2)，B_G1 ^SG2(2)と集合{b₃}との差集合を求めて、得られた差集合の値をB_G1 ^SG1(3)，B_G1 ^SG2(3)とすると、次のようになる。
タスクt_G1 ^SG1に対して：B_G1 ^SG1(2)−{b₃}＝{b₄,b₅}＝B_G1 ^SG1(3)
タスクt_G1 ^SG2に対して：B_G1 ^SG2(2)−{b₃}＝{b₄,b₅}＝B_G1 ^SG2(3)

次に、ブロックの相対アドレスが768であるブロックb₄をディスクからアクセスして、ブロックb₄内のデータをメインメモリに読み込み、すでに処理の済んだタスクt₂ ¹を除くグループ内のタスクt_G1 ^SG1，t_G1 ^SG2がブロックb₄で処理を行う必要があるかどうかを調べるために、ブロックb₄を集合{b₄}として表し、{b₄}とブロックの集合B_G1 ^SG1(3)，B_G1 ^SG2(3)との間で積集合を求めると次のようになる。
タスクt_G1 ^SG1に対して：B_G1 ^SG1(3)∩{b₄}＝{b₄}
タスクt_G1 ^SG2に対して：B_G1 ^SG2(3)∩{b₄}＝{b₄}
タスクt_G1 ^SG1，t_G1 ^SG2に対する積集合が{b₄}となり、タスクt_G1 ^SG1，t_G1 ^SG2がメインメモリに読み込んだブロックb₄で処理を行うことが必要となり、ブロックb₄は共通ブロックとなり、共通ブロックb₄でタスクt_G1 ^SG1，t_G1 ^SG2の処理を行うことになる。共通ブロックであるブロックb₄でのタスクの処理が終了すると、ブロックb₄を再びアクセスする必要がなくなるので、集合B_G1 ^SG1(3)，B_G1 ^SG2(3)と集合{b₄}との差集合を求める。得られた差集合の値をB_G1 ^SG1(4)，B_G1 ^SG2(4)とすると、次のようになる。
タスクt_G1 ^SG1に対して：B_G1 ^SG1(3)−{b₄}＝{b₅}＝B_G1 ^SG1(4)
タスクt_G1 ^SG2に対して：B_G1 ^SG2(3)−{b₄}＝{b₅}＝B_G1 ^SG2(4)

最後に、ブロックの相対アドレスが1024であるブロックb₅をディスクからアクセスして、ブロックb₅内のデータをメインメモリに読み込み、すでに処理の済んだタスクt₂ ¹を除くグループ内のタスクt_G1 ^SG1，t_G1 ^SG2がブロックb₅で処理を行う必要があるかどうかを調べるために、ブロックb₅を集合{b₅}として表し、集合{b₅}とブロックの集合B_G1 ^SG1(4)，B_G1 ^SG2(4)との間で積集合を求めると次のようになる。
タスクt_G1 ^SG1に対して：B_G1 ^SG1(4)∩{b₅}＝{b₅}
タスクt_G1 ^SG2に対して：B_G1 ^SG2(4)∩{b₅}＝{b₅}
タスクt_G1 ^SG1，t_G1 ^SG2に対する積集合が{b₅}となり、タスクt_G1 ^SG1，t_G1 ^SG2がメインメモリに読み込んだブロックb₅で処理を行うことが必要となり、ブロックb₅は共通ブロックとなり、共通ブロックb₅でタスクt_G1 ^SG1，t_G1 ^SG2の処理を行う。共通ブロックであるブロックb₅でのタスクの処理が終了すると、ブロックb₅を再びアクセスする必要がなくなるので、集合B_G1 ^SG1(4)，B_G1 ^SG2(4)と集合{b₅}との差集合を求める。得られた差集合の値をB_G1 ^SG1(5)，B_G1 ^SG2(5)とすると、次のようになる。
タスクt_G1 ^SG1に対して：B_G1 ^SG1(4)−{b₅}＝{}＝B_G1 ^SG1(5)
タスクt_G1 ^SG2に対して：B_G1 ^SG2(4)−{b₅}＝{}＝B_G1 ^SG2(5)
この結果、集合B_G1 ^SG1(5)，B_G1 ^SG2(5)が空集合{}になり、タスクt_G1 ^SG1，t_G1 ^SG2の処理が終了したことがわかり、これによってグループ内のすべてのタスクの処理が終了したことになる。

このように共通ブロックを利用して、ディスク内のリレーションのブロックを何度もアクセスすることなしに、グループ内のタスク処理を一度に行い、処理コストの小さいタスクから順番に次々と処理を行っていき、最後のタスク処理ですべてのタスク処理を終了させることができる。

図７は、リレーションEMPLOYEEに対するタスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2を、スタティック・マルチオペレーション・プロセッシングを使用して処理する様子を示す図である。
図７において、リレーションEMPLOYEEに対するタスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2の処理を、処理コストの小さいタスクからアクセスしてく状態（スキャン１からスキャン３にわたって）と、処理結果のリレーションTEMP_T1_2，TEMP_SG1_G1，TEMP_SG2_G1に書き込んだ結果を表わしている。
一連のタスクの処理を行うプロセス(501)は、ディスク内のブロックをスキャン１でb₂を、スキャン２でb₁を、スキャン３でb₃，b₄，b₅を、順にアクセスする。
プロセス(501)は、アクセスする各ブロックにおいて、そのブロックで処理を行う必要のあるグループ内のタスクの処理を一度に行い、処理結果をリレーションTEMP_T1_2，TEMP_SG1_G1，TEMP_SG2_G1に書き込み、すべてのブロックでのタスク処理が終了すると、スタティック・マルチオペレーション・プロセッシングによるグループG1のタスク処理は終了したことになる。

［（ａ−６）サブグループ内のタスクによる合成選択演算の処理結果の共有］
図７において、合成選択演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1(503)は、サブグループ内のタスクt₁ ³，t₃ ²，t₆ ³の処理結果のすべてを含んでいるため、サブグループ内のタスクt₁ ³，t₃ ²，t₆ ³は、合成選択演算タスクt_G1 ^SG1 の処理結果TEMP_SG1_G1(503)を部分的に共有することになる。

図７に示した合成選択演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1(503)は、選択条件に使用された属性BDATEの値で整列してあり、サブグループ内の個々のタスクt₁ ³，t₃ ²，t₆ ³の処理結果にそれぞれ対応する仮想リレーションTEMP_T3_1，TEMP_T2_3，TEMP_T3_6が処理結果TEMP_SG1_G1のレコードを部分的に共有している様子を表わしている。サブグループ内のタスクが合成関係演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1を部分的に共有していることを示すために、処理結果TEMP_SG1_G1内のレコードを合成選択演算の選択条件に使用された属性BDATEの値で整列したときに、サブグループ内の個々のタスクt₁ ³，t₃ ²，t₆ ³に対して、以下のように仮想リレーションTEMP_T3_1,TEMP_T2_3，TEMP_T3_6を作成する。仮想リレーションには共有する合成関係演算タスクの処理結果(リレーション)名、その処理結果を共有するレコードの格納位置（レコードの行範囲、レコードが格納されているブロックの番号とアドレス）を記録しておく。
TEMP_T3_1＝{リレーション:TEMP_SG1_G1; 行:1〜9; ブロック:b₁[0,256],b₂[256,512],b₃[512,768]};
TEMP_T2_3＝{リレーション:TEMP_SG1_G1; 行:13〜16; ブロック:b₄[768,-]};
TEMP_T3_6＝{リレーション:TEMP_SG1_G1; 行:7〜12; ブロック:b₂[256,512],b₃[512,768]};

仮想リレーションTEMP_T3_1は、サブグループSG1_G1内のタスクt₁ ³の処理結果であり、合成関係演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1のブロックb₁，b₂，b₃に格納してあるレコードの1行から9行までを共有していることを表わしている。
仮想リレーションTEMP_T2_3は、サブグループSG1_G1内のタスクt₃ ²の処理結果であり、TEMP_SG1_G1のブロックb₄に格納してあるレコードの13行から16行までを共有していることを表わしている。
仮想リレーションTEMP_T3_6は、サブグループSG1_G1内のタスクt₆ ³の処理結果であり、TEMP_SG1_G1のブロックb₂，b₃に格納してあるレコードの7行から12行までを共有していることを表わしている。

［（ａ−７）合成選択演算の処理結果を共有するための手順］
合成選択演算タスクの処理結果得られたリレーションのレコードをサブグループ内個々の選択演算タスクが仮想リレーションを用いて部分的に共有するには、以下の手順を用いることになる。
（i）合成選択演算タスクの処理結果内のレコードは合成選択演算の選択条件に使用された属性の値で整列する。
（ii）整列された処理結果内のレコードをスキャンし、１つ１つのレコードがサブグループ内個々の選択演算タスクの選択条件を満たしているかどうかを調べていく。
（iii）合成選択演算タスクの処理結果において、どの行からどの行までのレコードがサブグループ内個々の選択演算タスクの選択範囲内のレコードであったかをそれぞれの処理結果である仮想リレーションに記録しておく。

前述したよう合成選択演算t_G1 ^SG1の処理結果TEMP_SG1_G1中からレコードを部分的に共有するサブグループSG1_G1内のタスクは次のようなものである。
サブグループ SG1_G1＝{t₁ ³,t₃ ²,t₆ ³}
(t₁ ³)：TEMP_T3_1←σ_{BDATE<'DEC-31-1961'}EMPLOYEE
(t₃ ²)：TEMP_T2_3←σ_{BDATE>'JAN-1-1971'}EMPLOYEE
(t₆ ³)：TEMP_T3_6←σ_{BDATE>'FEB-11-1959' AND BDATE<NOV-21-1966'}EMPLOYEE

図８−１，図８−２は、variable length record（可変長レコード），contiguous block allocation（隣接したブロックの配置），unspanned record（２つのブロックにまたがって格納されないレコード）のファイル形式で表せられる合成選択演算タスクt_G1 ^SG1の処理結果TEMP_G1_SG1(600)内のレコードを、合成選択演算の選択条件に使用された属性BDATEの値をもとに、マージソートとクイックソートの２つのソートアルゴリズムを組み合わせて整列し、整列された処理結果(613)内のレコードを、サブグループSG1_G1内の選択演算タスクt₁ ³，t₃ ²，t₆ ³の処理結果である仮想リレーションTEMP_T3_1，TEMP_T2_3，TEMP_T3_6が部分的に共有するための手順を表している。

（１）最初にマージソートを適用してリレーション内のブロック列をブロック数が１つになるまで再帰的に２つに分割していく（図８−１：600〜606）。

（２）ブロック列内のブロック数が１つになると、ブロック列（図８−１：603〜606）をそれ以上分割することはできないので、ブロック列内のブロックb₁〜b₄を順番にメインメモリに読み込んで、属性BDATEの値をもとにブロック内のレコードを整列する。ブロック内のレコードを整列するにあたって、ブロック内の可変長レコードはそれぞれサイズが異なるので（バイト数が異なるので）、ブロック内の個々のレコードに対してポインタ（レコードのアドレス）（図８−１：614〜617）をメインメモリ内に配列させ、クイックソートを用いて配列されたポインタをポインタが持つレコードの値（レコードのアドレスから求められるレコードのBDATEの値）をもとに整列する。

（３）整列されたポインタの順番（図８−２：618〜621）に従ってブロック内のレコードを並びかえる。

（４）ブロック内のレコードが整列されると、次はマージソートによる再起の呼び出しから戻るときに（図８−２：607〜613）、整列済みの２つのブロック列から１つのブロック列に結合していく。結合するにあたっては、結合するレコードを整列された順番で並べていく。

（５）最後に２つのブロック列（図８−２：611，612）が１つのブロック列(613)に結合される際に、１つ１つのレコードがサブグループSG1_G1内の選択演算タスクt₁ ³，t₃ ²，t₆ ³の選択条件をそれぞれ満たしているかどうかを一度に調べていく。

（６）ブロック列（図８−２：613）にすべてレコードが整列されると、タスクt₁ ³，t₃ ²，t₆ ³に対して、ブロック列(613)に加えられたレコードの中でどの行からどの行までのレコードが選択範囲内のレコードであったかを仮想リレーションTEMP_T3_1，TEMP_T2_3，TEMP_T3_6に記録しておくことになる。仮想リレーションTEMP_T3_1，TEMP_T2_3，TEMP_T3_6には実際のレコードを加えるのではなく、前述したように整列された処理結果(613)を部分的に共有するレコードの格納位置(レコードの行範囲及びそれらのレコードが格納してあるブロックの番号とアドレス)を記録しておくことになる。

このようにして、サブグループSG1_G1内の選択演算タスクt₁ ³，t₃ ²，t₆ ³が合成選択演算タスクt_G1 ^SG1の処理結果TEMP_G1_SG1内のレコードを部分的に共有できるのは、処理結果TEMP_G1_SG1(613)内のレコードを整列するために用いた属性BDATEを、タスクt₁ ³，t₃ ²，t₆ ³が個々の選択条件に使用しているからである。このレコードを共有する範囲を調べる作業は、以上に述べた方法のようにリレーション内のレコードを最終的にブロック列(613)を形成するときに行うことが重要である。その理由は、最終的にブロック列(613)で整列した後に、サブグループ内のタスクのレコードの共有する範囲を求めると、再度、リレーション内のすべてのレコードをディスクから読み直さなければならなくなり、そのためにディスクアクセスが必要になるからである。

その他、処理結果内のレコードを整列する必要がない場合、すなわち合成選択演算の選択条件に使用されている属性が主属性である場合は、処理結果内のレコードはすでに整列された順番に格納されていくことになるので、処理結果にレコードを加える際に、サブグループ内の個々の選択演算タスクの選択条件を満たしているかを一度に調べていくことになる。

以上のようにして、サブグループに集められたいくつかの選択演算タスクを１つの合成選択演算タスクt_G1 ^SG1に置き換えて処理を行うと、サブグループSG1_G1内のタスクt₁ ³，t₃ ²，t₆ ³に対応する仮想リレーションは処理結果TEMP_SG1_G1内のレコードを部分的に共有することになり、サブグループ内の個々のタスクt₁ ³，t₃ ²，t₆ ³の間で選択範囲の重なっているレコードを含んだ処理結果のリレーションをディスク上に別々に作成する必要がなくなるので、ディスクをアクセスする回数を減少させ、クエリーの処理速度を向上させることができる。

また、仮想リレーションを作成して合成選択演算タスクの処理結果を共有するその他の理由は、仮想リレーションを用いて合成選択演算タスクの処理結果に対して処理を行うタスクを別々に処理するのではなく、マルチオペレーション・プロセッシングを用いて一度に処理するためである。そのため仮想リレーションを用いて処理を行うタスクは、仮想リレーションをもとにしてグループ分けをするのではなく、仮想リレーションを包含している合成関係演算タスクの処理結果のリレーションをもとにグループ分けを行い、仮想リレーションに記録してある情報から共通ブロックを見出し、グループ内のタスク処理を一度に行っていくことになる。

このようにして、仮想リレーションを用いたタスク処理を一度に行うと、合成選択演算の処理結果内のブロックは一度しかアクセスされないので、ディスクをアクセスする回数を減少させ、クエリーの処理速度を向上させることができる。

［（ａ−８）その他の合成関係演算の処理結果の共有］
グループG1の合成関係演算タスクt_G1 ^SG2の処理結果TEMP_SG2_G1は、サブグループSG2_G1内のタスクt₄ ¹，t₅ ¹によって共有されることになる。合成関係演算タスクt_G1 ^SG2は結合演算であり、サブグループSG2_G1内のタスクt₄ ¹，t₅ ¹は、同一のタスク（t₄ ¹≡t₅ ¹）なので、タスクt₄ ¹の処理結果TEMP_T1_4とタスクt₅ ¹の処理結果TEMP_T1_5は、合成関係演算タスクt_G1 ^SG2の処理結果TEMP_SG2_G1をそのまま、それぞれのタスクの処理結果として使用することになる(TEMP_T1_4≡TEMP_T1_5≡TEMP_SG2_G1)。

［（ａ−９）新たなグループの作成］
マルチオペレーション・プロセッシングを使用してグループG1内の合成関係演算タスクt_G1 ^SG1，t_G1 ^SG2及びサブグループに集まらないタスクt₂ ¹の処理が、タスクt₂ ¹，t_G1 ^SG1，t_G1 ^SG2の順番で終了すると、図４−１〜図４−３の処理ツリーからトポロジカルソートの順番で新たに処理できるタスクを見出していくことになる。
最初にタスクt₂ ¹が終了すると、処理ツリーP₂からわかるように、新たにタスクt₂ ²の処理を始めることができるようになる。タスクt₂ ²は、タスクt₂ ¹の処理結果TEMP_T1_2に対して処理を行うタスクとして、新たにグループG5（これまでのグループG4に加えて）を作成してグループG5にタスクt₂ ²を加えることにする。

次に、タスクt_G1 ^SG1の処理が終了すると、サブグループSG1_G1内のタスクt₁ ³，t₃ ²，t₆ ³の処理が終了することになり、処理ツリーP₁，P₃，P₆からわかるように、新たにタスクt₁ ⁴，t₃ ³，t₆ ⁴の処理ができるようになる。タスクt₁ ⁴，t₃ ³，t₆ ⁴はそれぞれアクセスする仮想リレーションが異なるが、タスクt₁ ⁴はタスクt₁ ³の処理結果である仮想リレーションTEMP_T3_1を包含している合成選択演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1をアクセスし、タスクt₃ ³はタスクt₃ ²の処理結果である仮想リレーションTEMP_T2_3を包含している合成選択演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1をアクセスし、タスクt₆ ⁴はタスクt₆ ³の処理結果である仮想リレーションTEMP_T3_6を包含している合成選択演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1をアクセスするので、これらの新たなタスクt₁ ⁴，t₃ ³，t₆ ⁴は共通のリレーションTEMP_SG1_G1に対して処理を行うタスクとして、新たにグループG6を作成して、グループG6にタスクt₁ ⁴，t₃ ³，t₆ ⁴を加えることにする。

最後に、タスクt_G1 ^SG2の処理が終了すると、サブグループSG2_G1内のタスクt₄ ¹，t₅ ¹の処理が終了することになり、処理ツリーP₄，P₅からわかるように、グループG4に集められたタスクt₄ ²，t₅ ²の処理が終了していないため、新たに処理できるタスクは見出されないのでグループは作成されない。

以上のことをまとめると、グループG1内のタスクの処理が終了することによって新たに見出されたタスクt₂ ²，t₁ ⁴，t₃ ³，t₆ ⁴がアクセスする処理結果のリレーションをもとに、次のようにグループG5，グループG6が作成される。
TEMP_T1_2：グループ G5＝{t₂ ²}
(t₂ ²)：TEMP_T2_2←π_{SSN,LNAME,BDATE}TEMP_T1_2
TEMP_SG1_G1：グループ G6＝{t₁ ⁴,t₃ ³,t₆ ⁴}
(t₁ ⁴)：TEMP_T4_1←π_{SSN,LNAME,DNUM}TEMP_T3_1
(t₃ ³)：TEMP_T3_3←π_{SSN,FNAME,LNAME,DNUM}TEMP_T2_3
(t₆ ⁴)：TEMP_T4_6←π_{FNAME,LNAME,DNUM}TEMP_T3_6

グループG5には、タスクt₂ ¹の処理結果TEMP_T1_2に対して処理を行うタスクt₂ ²が集められることになり、グループG6には、合成選択演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1に対して処理を行うタスクt₁ ⁴，t₃ ³，t₆ ⁴が集められることになる。

［（ｂ）グループG2の処理］
次に、マルチオペレーション・プロセッシングを使用してグループG2内の合成射影演算タスクt_G2 ^SG1及びサブグループに集まらないタスクt₁ ¹，t₆ ¹の処理を一度に行うことにする。前述したように、グループG2内の各タスクは次のようなものである。
DEPARTMENT：グループ G2＝{t_G2 ^SG1,t₁ ¹,t₆ ¹}
(t_G2 ^SG1)：TEMP_SG1_G2←π_{DNUMBER,DNAME,MGRSSN}DEPARTMENT
(t₁ ¹)： TEMP_T1_1←σ_{DPHONE=23-3732}DEPARTMENT
(t₆ ¹)： TEMP_T1_6←σ_DNUMBER=7DEPARTMENT

［（ｂ−１）各タスクのアクセスプラン］
まず、グループG2内の合成射影演算タスクt_G2 ^SG1及びサブグループに集められないタスクt₁ ¹，t₆ ¹に対して次のようなアクセスプランを作成する。
plan(t_G2 ^SG1)：DEPARTMENTをスキャンして射影演算を行う。
plan(t₁ ¹)：DEPARTMENTの2次インデックスを使用して１つのレコードを検索する。
plan(t₆ ¹)：DEPARTMENTの主インデックスを使用して１つのレコードを検索する。

［（ｂ−２）各タスクの処理コスト］
各タスクに対してアクセスプランを作成すると、アクセスプランをもとに、各タスクの処理コストを計算する。
タスクt_G2 ^SG1の処理コスト：cost(t_G2 ^SG1)＝b_D＝5
タスクt₁ ¹の処理コスト：cost(t₁ ¹)＝x_D2+1＝3
タスクt₆ ¹の処理コスト：cost(t₆ ¹)＝x_D1+1＝2
タスクt_G2 ^SG1の処理コストは、リレーションDEPARTMENTをスキャンして射影演算の処理を行うために、リレーション中のすべてのブロックをアクセスする処理コストなのでb_D＝5である。

タスクt₁ ¹の処理コストは、リレーションDEPARTMENTの２次インデックス(102)を使用して１つのレコードを検索する処理コストである。これは２次インデックスのレベルx_D2とブロックをアクセスする処理コストであり、図３−１のリレーションDEPARTMENTの２次インデックス(102)のレベルx_D2は2であるので、処理コストはx_D2+1＝3である。
タスクt₆ ¹の処理コストは、リレーションDEPARTMENTの主インデックス(100)を使用して１つのレコードを検索する処理コストである。x_D1+1は、リレーションDEPARTMENTの主インデックス(100)を使用して目的のデータを見つけるためにアクセスするインデックスのレベルx_D1と当面のブロックをアクセスする処理コストである。図３−１のリレーションDEPARTMENTの主インデックス(100)のレベルは１であるので(x_D1＝1となり)、タスクt₆ ¹の処理コストはx_D1+1＝2である。

以上のように処理コストを計算すると、処理コストをもとにグループ内のタスクを処理コストの小さい順番から並べ替えると次のようになる。
sort(t_G2 ^SG1,t₁ ¹,t₆ ¹)⇒(t₆ ¹,t₁ ¹,t_G2 ^SG1)

［（ｂ−３）各タスクに対応するブロック集合］
タスクt₆ ¹，t₁ ¹，t_G2 ^SG1に対して、インデックスを使用して、アクセスする必要のあるすべてのブロックを事前に調べて、各タスクに対応するブロック集合B₆ ¹，B₁ ¹，B_G2 ^SG1に集めると、次のようになる。
タスクt₆ ¹に対して：B₆ ¹＝{b₂}
タスクt₁ ¹に対して：B₁ ¹＝{b₅}
タスクt_G2 ^SG1に対して：B_G2 ^SG1＝{b₁,b₂,b₃,b₄,b₅}
このように、各タスクt₆ ¹，t₁ ¹，t_G2 ^SG1 に対応するブロック集合B₆ ¹，B₁ ¹，B_G2 ^SG1を見出すことができるのは、以下に示すような理由にもとづくからである。
タスクt₆ ¹は、選択条件”DNUMBER＝7”を満たすレコードが必要である。リレーションDEPARTMENTの主インデックスを使用すると、属性DNUMBERの値が7であるレコードはブロックの相対アドレスが256であるブロックb₂に格納してあることがわかり、ブロックb₂だけをアクセスすることが必要となるので、タスクt₆ ¹の処理を行うためにアクセスする必要のあるブロックの集合は{b₂}となる。

タスクt₁ ¹は、選択条件”DPHONE＝23-3732”を満たすレコードが必要である。リレーションDEPARTMENTの２次インデックスを使用すると、属性DPHONEの値が23-3732であるレコードはブロックの相対アドレスが1024であるブロックb₅に格納してあることがわかり、ブロックb₅だけをアクセスすることが必要となるので、タスクt₁ ¹の処理を行うためにアクセスする必要のあるブロックの集合は{b₅}となる。
タスクt_G2 ^SG1は、射影演算の処理を行うために、リレーションDEPARTMENT内の最初のブロックb₁から最後のブロックb₅までのブロックをアクセスすることが必要となるので、タスクt_G2 ^SG1の処理を行うためにアクセスする必要のあるブロック集合は｛b₁,b₂,b₃,b₄,b₅｝となる。

［（ｂ−４）アクセスすべきブロック（共通ブロック）の順位の決定］
以上のように、各タスクに対応するブロック集合を見出した後に、処理コストの小さいタスクから処理コストの大きいタスクへと順番に、すなわちタスクt₆ ¹，t₁ ¹，t_G2 ^SG1の順番に各タスクに対応するブロック集合の和集合を求めていくことにする。
まず、TB₀＝{}（空集合）として、TB₀とタスクt₆ ¹に対応するブロック集合B₆ ¹と和集合TB₆ ¹を求める。次に、このTB₆ ¹とタスクt₁ ¹に対応するブロック集合B₁ ¹の和集合TB₁ ¹を求める。さらに、このTB₁ ¹とタスクt_G2 ^SG1に対応するブロック集合B_G2 ^SG1との和集合TB_G2 ^SG1を求めると次のようになる。この場合、和集合を求めるに当たっては、新たに加える集合は和集合の中で最後に加えていくものとする。
TB₀＝{}
タスクt₆ ¹に対応する集合B₆ ¹との和集合：TB₆ ¹＝TB₀∪B₆ ¹＝{b₂}
タスクt₁ ¹に対応する集合B₁ ¹との和集合：TB₁ ¹＝TB₆ ¹∪B₁ ¹＝{b₂,b₅}
タスクt_G2 ^SG1に対応する集合B_G2 ^SG1との和集合：TB_G2 ^SG1＝TB₁ ¹∪B_G2 ^SG1＝{b₂,b₅,b₁,b₃,b₄}

以上のように、処理コストの小さいタスクに対応するブロック集合から処理コストの大きいタスクに対応するブロック集合へと順番に和集合を求めていくと、最後のタスク（処理コストの１番大きいタスク）に対応するブロック集合との和集合TB_G2 ^SG1から、ディスクのブロックb₂からアクセスを開始し、ブロックb₄でアクセスを終了すればよいことになり、ディスクにおけるリレーションDEPARTMENT内のブロックへのアクセスの順番を（b₂,b₅,b₁,b₃,b₄）のように決定することができる。このような方法で和集合を求めることは、処理コストの小さいタスクから順番に処理を行うに当たって、ディスク内のブロックをどのような順番でアクセスすればよいか、その順番を決定するためである。このようにして得られたブロックb₂，b₅，b₁，b₃，b₄は、タスクt₆ ¹，t₁ ¹，t_G2 ^SG1を順番に処理していくときに共用され得るので、これらのブロックを共通ブロックと呼ぶことにする。

前述したブロック集合B₆ ¹，B₁ ¹，B_G2 ^SG1の中に含まれているブロックを見ると、ブロックb₂は、タスクt₆ ¹，t_G2 ^SG1を処理するために使用され、ブロックb₅は、タスクt₁ ¹，t_G2 ^SG1を処理するために使用され、ブロックb₁，b₃，b₄は、タスクt_G2 ^SG1を処理するために使用されることがわかる。これらのブロックを共通ブロックとして扱うことにすると、これらの共通ブロックを必要とするタスクを共通ブロック上で一度に処理することができる。以上のことをまとめると次のような表になる。

［（ｂ−５）共通ブロックでのタスクの処理］
以上のように、それぞれの共通ブロックでどのようなタスクが処理されるかを見出すためには、タスクt₆ ¹，t₁ ¹，t_G2 ^SG1に対して作成されたブロック集合B₆ ¹，B₁ ¹，B_G2 ^SG1の情報にもとづいて、次に記述するような手順を用いればよい。
最初に、ブロックの相対アドレスが256であるブロックb₂をディスクからアクセスして、ブロックb₂内のデータをメインメモリに読み込み、グループ内のタスクt₆ ¹，t₁ ¹，t_G2 ^SG1がブロックb₂で処理を行う必要があるかどうかを調べるため、ブロックb₂を集合{b₂}として表し、この集合{b₂}とブロックの集合B₆ ¹，B₁ ¹，B_G2 ^SG1との間でそれぞれ積集合（Intersection）を求めると次のようになる。
タスクt₆ ¹に対して：B₆ ¹∩{b₂}＝{b₂}
タスクt₁ ¹に対して：B₁ ¹∩{b₂}＝{}
タスクt_G2 ^SG1に対して：B_G2 ^SG1∩{b₂}＝{b₂}

タスクt₁ ¹を除くタスクt₆ ¹，t_G2 ^SG1に対する積集合が{b₂}となり、タスクt₆ ¹，t_G2 ^SG1がメインメモリに読み込んだブロックb₂で処理を行う必要があることが明らかになり、ブロックb₂は共通ブロックとなり、共通ブロックb₂で各タスクの処理を行うことになる。共通ブロックであるブロックb₂でのタスクの処理が終了するとブロックb₂を再びアクセスする必要がなくなるので、集合B₆ ¹，B_G2 ^SG1と集合{b₂}との差集合（Difference）を求める。得られた差集合の値をB₆ ^{1 (1)}，B_G2 ^SG1(1)とすると、次のようになる。
タスクt₆ ¹に対して：B₆ ¹−{b₂}＝{}＝B₆ ¹⁽¹⁾
タスクt_G2 ^SG1に対して：B_G2 ^SG1−{b₂}＝{b₁,b₃,b₄,b₅}＝B_G2 ^SG1(1)
この結果、集合B₆ ¹⁽¹⁾が空集合{}になりタスクt₆ ¹の処理が終了したことがわかる。

次に、ブロックの相対アドレスが1024であるブロックb₅をディスクからアクセスして、ブロックb₅内のデータをメインメモリに読み込み、すでに処理の済んだタスクt₆ ¹を除くグループ内のタスクt₁ ¹，t_G2 ^SG1がブロックb₅で処理を行う必要があるかどうかを調べるために、ブロックb₅を集合{b₅}として表し、{b₅}とブロックの集合B₁ ¹，B_G2 ^SG1(1)との間でそれぞれ積集合を求めると次のようになる。
タスクt₁ ¹に対して：B₁ ¹∩{b₅}＝{b₅}
タスクt_G2 ^SG1に対して：B_G2 ^SG1(1)∩{b₅}＝{b₅}

タスクt₁ ¹，t_G2 ^SG1に対する積集合が{b₅}となり、タスクt₁ ¹，t_G2 ^SG1がメインメモリに読み込んだブロックb₅で処理を行うことが必要となり、ブロックb₅は共通ブロックとなり、共通ブロックb₅でタスクt₁ ¹，t_G2 ^SG1の処理を行うことになる。共通ブロックであるブロックb₅でのタスクの処理が終了すると、ブロックb₅を再びアクセスする必要がなくなるので、集合B₁ ¹，B_G2 ^SG1(1)と集合{b₅}との差集合を求める。得られた差集合の値をB₁ ¹⁽¹⁾，B_G2 ^SG1(2)とすると、次のようになる。
タスクt₁ ¹に対して：B₁ ¹−{b₅}＝{}＝B₁ ¹⁽¹⁾
タスクt_G2 ^SG1に対して：B_G2 ^SG1(1)−{b₅}＝{b₁,b₃,b₄}＝B_G2 ^SG1(2)
この結果、集合B₁ ¹⁽¹⁾が空集合{}になりタスクt₁ ¹の処理が終了したことがわかる。この段階で、グループに残ったタスクはt_G2 ^SG1のみとなるので、リレーションDEPARTMENTから残ったブロックb₁，b₃，b₄をアクセスしてタスクt_G2 ^SG1の処理を行い、タスクt_G2 ^SG1の処理が終了するとグループ内すべてのタスクの処理が終了することになる。

図９は、スタティックマルチオペレーション・プロセッシングを使用して、リレーションDEPARTMENTに対するタスクt₆ ¹，t₁ ¹，t_G2 ^SG1の処理コストの小さいタスクからアクセスしていく状態（スキャン１からスキャン５にわたって）と処理結果をリレーションTEMP_T1_6(704)，TEMP_T1_1(703)，TEMP_SG1_G2(705)に書き込んだ結果を表わした図である。
一連のタスクの処理を行うプロセス(701)は、ディスク内のブロックを、図９で示すように、ブロックb₂，b₅，b₁，b₃，b₄の順番でアクセスし、各ブロックにおいて、そのブロックで処理を行う必要のあるグループ内のタスクの処理を行い、処理結果をリレーションTEMP_T1_6(704)，TEMP_T1_1(703)，TEMP_SG1_G2(705)に書き込み、すべてのブロックでのタスク処理が終了するとスタティックマルチオペレーション・プロセッシングによるグループG2のタスク処理は終了したことになる。

［（ｂ−６）合成射影演算タスクの処理結果の作成］
合成射影演算タスクt_G2 ^SG1の処理結果TEMP_SG1_G2は、サブグループSG1_G2内の射影演算タスクt₂ ³，t₃ ¹によって部分的に共有されることになる。前述したようにサブグループSG1_G2内のタスクは次のようなものである。
サブグループ SG1_G2＝{t₂ ³,t₃ ¹}
(t₂ ³)：TEMP_T3_2←π_{DNUMBER,DNAME,MGRSSN}DEPARTMENT
(t₃ ¹)：TEMP_T1_3←π_{DNUMBER,DNAME}DEPARTMENT
合成射影演算タスクt_G2 ^SG1の処理結果TEMP_SG1_G2内の属性（列）をサブグループSG1_G2内の射影演算タスクt₂ ³，t₃ ¹が部分的に共有するには、合成射影演算タスクt_G2 ^SG1の処理を行った際に、処理結果TEMP_SG1_G2を共有するサブグループSG1_G2内のタスクt₂ ³，t₃ ¹に対して、図９に示した仮想リレーションTEMP_T3_2，TEMP_T1_3を作成することにする。仮想リレーションには、共有する合成射影演算の処理結果(リレーション)名、その処理結果を共有する属性の格納位置(列番号)を次のように記録しておくことにする。
TEMP_T3_2＝{リレーション:TEMP_SG1_G2; 列:1,2,3};
TEMP_T1_3＝{リレーション:TEMP_SG1_G2; 列:1,2};

仮想リレーションTEMP_T3_2は、サブグループSG1_G2内のタスクt₂ ³の処理結果であり、合成射影演算タスクt_G2 ^SG1の処理結果TEMP_SG1_G2の列1，2，3を共有する。
仮想リレーションTEMP_T1_3は、サブグループSG1_G2内のタスクt₃ ¹の処理結果であり、合成射影演算タスクt_G2 ^SG1の処理結果TEMP_SG1_G2の列1，2を共有する。
以上のようにして、サブグループに集められたいくつもの射影演算タスクを１つの合成射影演算タスクt_G2 ^SG1に置き換えて処理を行い、サブグループSG1_G2内のタスクt₂ ³，t₃ ¹は、仮想リレーションを通して処理結果TEMP_SG1_G2内の属性（列）を部分的に共有することになり、サブグループ内の個々のタスクt₂ ³，t₃ ¹に対して射影する属性が重なっているレコードを含んだ処理結果のリレーションをディスク上に別々に作成する必要がなくなるので、ディスクをアクセスする回数を減少させ、クエリーの処理速度を向上させることが可能になる。

図９の合成射影演算タスクt_G2 ^SG1の処理結果TEMP_SG1_G2(705)は、仮想リレーションTEMP_T3_2と仮想リレーションTEMP_T1_3によって共有されている様子を表わしている。マルチオペレーション・プロセッシングを使用して合成関係演算タスクの処理結果を作成するにあたって、合成関係演算タスクの処理結果内のレコードに対して、結合演算などのタスクによって検索処理が行われる場合は、検索処理に使用される属性に対してインデックスを作成しておく。

図９の合成射影演算タスクt_G2 ^SG1の処理結果TEMP_SG1_G2(705)内のレコードは、サブグループSG1_G2内のタスクt₂ ³，t₃ ¹の処理終了後に、図４−１〜図４−３の処理ツリーが示すように、結合演算タスクt₂ ⁶，t₃ ⁴によって検索されるため、検索処理に使用される属性DNUMBERに対してインデックス(702)を作成している。結合演算タスクt₂ ⁶は仮想リレーションTEMP_T3_2に対して検索処理を行うタスクであり、結合演算タスクt₃ ⁴は仮想リレーションTEMP_T1_3に対して検索処理を行うタスクであり、仮想リレーションTEMP_T3_2と仮想リレーションTEMP_T1_3はリレーションTEMP_SG1_G2(705)内の属性(列)を部分的に共有しているので、リレーションTEMP_SG1_G2に対して作成されたインデックス(702)は結合演算タスクt₂ ⁶，t₃ ⁴の検索処理のために共有されることになる。タスクt₂ ⁶はインデックス(702)を用いてリレーションTEMP_SG1_G2(705)からレコードを検索し、検索されたレコードが仮想リレーションTEMP_T3_2内に含まれているときには、仮想リレーションTEMP_T3_2からレコードを検索したことになる。同様に、タスクt₃ ⁴はインデックス(702)を用いてリレーションTEMP_SG1_G2(705)からレコードを検索し、検索されたレコードが仮想リレーションTEMP_T1_3内に含まれているときには、仮想リレーションTEMP_T1_3からレコードを検索したことになる。レコードが検索されると、検索されたレコードから個々の仮想リレーションに記録してある必要な属性（列）のみを射影することになる。

このようにして、合成関係演算タスクの処理結果に対してインデックスを作成しておくと、仮想リレーションに対してレコードを検索するタスクは、インデックスを共有することができるようになり、個々の仮想リレーションに対して別々にインデックスを作成する必要がなくなるので、ディスクをアクセスする回数を減少させて、クエリーの処理速度を向上させることが可能になる。

［（ｂ−７）新たなグループの作成］
以上のように合成関係演算を利用したマルチオペレーション・プロセッシングを使用してグループG2内の合成射影演算タスクt_G2 ^SG1及びサブグループに集まらないタスクt₆ ¹，t₁ ¹の処理が、タスクt₆ ¹，t₁ ¹，t_G2 ^SG1の順番で終了し、合成射影演算タスクt_G2 ^SG1の処理結果TEMP_SG1_G2に対してインデックスが作成されると、図４−１〜図４−３の処理ツリーからトポロジカルソートの順番で新たに処理できるタスクを見出していくことになる。

最初に、タスクt₆ ¹が終了すると処理ツリーP₆からわかるように新たにタスクt₆ ²の処理を始めることができるようになる。タスクt₆ ²は、タスクt₆ ¹の処理結果TEMP_T1_6に対して処理を行うタスクとして新たにグループG7を作成してグループG7にタスクt₆ ²を加えることになる。
次に、タスクt₁ ¹が終了すると処理ツリーP₁からわかるように新たにタスクt₁ ²の処理を始めることができるようになる。タスクt₁ ²は、タスクt₁ ¹の処理結果TEMP_T1_1に対して処理を行うタスクとして新たにグループG8を作成してグループG8にタスクt₁ ²を加えることになる。

最後、にタスクt_G2 ^SG1の処理が終了すると、サブグループSG1_G2内のタスクt₂ ³，t₃ ¹の処理が終了することになり、処理ツリーP₂，P₃からわかるように、グループG3に集められたタスクt₂ ⁴の処理とグループG6に集められたタスクt₃ ³の処理が終了していないので、新たに処理できるタスクは見出されないのでグループは作成することはない。
以上のことをまとめるとグループG2内のタスクの処理が終了することによって新たに見出されたタスクt₆ ²，t₁ ²をアクセスする処理結果のリレーションをもとに次のようにグループG7，グループG8が作成される。
TEMP_T1_6：グループ G7＝{t₆ ²}
(t₆ ²)：TEMP_T2_6←π_{DNUMBER,DNAME}TEMP_T1_6
TEMP_T1_1：グループ G8＝{t₁ ²}
(t₁ ²)：TEMP_T2_1←π_{DNUMBER,DNAME}TEMP_T1_1
グループG7には、タスクt₆ ¹の処理結果TEMP_T1_6に対して処理を行うタスクt₆ ²が集められることになる。グループG8には、タスクt₁ ¹の処理結果TEMP_T1_1に対して処理を行うタスクt₁ ²が集められることになる。

［（ｃ）グループG3の処理］
グループG2の処理が終了すると、次はグループG3内の合成選択演算タスクt_G3 ^SG1の処理を行うことになる。前述したようにグループG3内の合成選択演算タスクは次のようなものである。
PROJECT：グループ G3＝{t_G3 ^SG1}
(t_G3 ^SG1)：TEMP_SG1_G3←σ_{PLOCATION='New York' AND (PNAME='Aquarius' OR PNAME='Stafford')}PROJECT
グループG3には１つのタスクしか存在しないため、合成選択演算タスクt_G3 ^SG1の処理を直接行うことになる。合成選択演算タスクt_G3 ^SG1の処理が終了すると、PLOCATONがNew Yorkであり、PNAMEが'Aquarius' または'Stafford'であるレコードを２件ほど含んだ処理結果TEMP_SG1_G3を作成する。処理結果TEMP_SG1_G3内のレコードは属性PNAMEの値で整列し、サブグループSG1_G3内のタスクt₁ ⁷，t₂ ⁴に対しては次のような仮想リレーションを作成する。
TEMP_T7_1＝{リレーション:TEMP_SG1_G3; 行:1; ブロック:b₁};
TEMP_T4_2＝{リレーション:TEMP_SG1_G3; 行:2; ブロック:b₁};
仮想リレーションTEMP_T7_1は、サブグループSG1_G3内のタスクt₁ ⁷の処理結果であり、TEMP_SG1_G3のブロックb₁に格納されている属性PNAMEの値がAquariusである１行目のレコードを共有することになる。

仮想リレーションTEMP_T4_2は、サブグループSG1_G3内のタスクt₂ ⁴の処理結果であり、TEMP_SG1_G3のブロックb₁に格納されている属性PNAMEの値がStaffordである２行目のレコードを共有することになる。
グループG3内の合成選択演算タスクt_G3 ^SG1の処理が終了すると、サブグループSG1_G3内のタスクt₁ ⁷，t₂ ⁴の処理が終了することになり、図４−１〜図４−３の処理ツリーP₁，P₂からわかるように、新たにタスクt₁ ⁸，t₂ ⁵を処理できるようになる。
タスクt₁ ⁸，t₂ ⁵はそれぞれアクセスする仮想リレーションが異なるが、タスクt₁ ⁸は、タスクt₁ ⁷の処理結果である仮想リレーションTEMP_T7_1を通して、合成選択演算タスクt_G3 ^SG1の処理結果TEMP_SG1_G3をアクセスし、タスクt₂ ⁵は、タスクt₂ ⁴の処理結果である仮想リレーションTEMP_T4_2を通して、合成選択演算タスクt_G3 ^SG1の処理結果TEMP_SG1_G3をアクセスすることになるので、共通のリレーションTEMP_SG1_G3に対して処理を行うタスクとして、新たにグループG9を作成して、グループG9にタスクt₁ ⁸，t₂ ⁵を加えることになる。

以上のことをまとめると、グループG3内のタスク処理が終了することによって見出されたタスクt₁ ⁸，t₂ ⁵を次のようにグループG9に集めることになる。
TEMP_SG1_G3：グループG9＝{t₁ ⁸,t₂ ⁵}
(t₁ ⁸)：TEMP_T8_1←π_{PNUMBER,PNAME}TEMP_T7_1
(t₂ ⁵)：TEMP_T5_2←π_{PNUMBER,PNAME,DNUM}TEMP_T4_2

［（ｄ）グループG4の処理］
次に、マルチオペレーション・プロセッシングを適用してグループG4内のタスクt₁ ⁹，t₄ ²，t₅ ²の処理を一度に行うことになる。前述したように、グループG4内の各タスクは次のようなものである。
WORKS_ON：グループ G4＝{t₁ ⁹,t₄ ²,t₅ ²}
(t₁ ⁹)：TEMP_T9_1←π_ESSN,PNOWORKS_ON
(t₄ ²)：TEMP_T2_4←PROJECT |X|_PNUMBER=PNOWORKS_ON
(t₅ ²)：TEMP_T2_5←σ_HOURS<10WORKS_ON
ここではマルチオペレーション・プロセッシングによるG4内のタスクt₁ ⁹，t₄ ²，t₅ ²の処理の説明は省略することにする。マルチオペレーション・プロセッシングによってグループG4内のタスクt₁ ⁹，t₄ ²，t₅ ²の処理を行うと、図４−１〜図４−３の処理ツリーからトポロジカルソートの順番で新たに処理できるタスクを見出していくことになる。

最初に、タスクt₁ ⁹の処理が終了すると、処理ツリーP₁からわかるように、グループG9内のタスクt₁ ⁸の処理が終了していないため、新たに処理できるタスクは見出されないので、グループは作成されないままである。
次に、タスクt₄ ²の処理が終了すると、処理ツリーP₄からわかるように、グループG1内のタスクt₄ ¹の処理はすでに終了しているので、新たにタスクt₄ ³の処理を始めることができるようになる。タスクt₄ ³はタスクt₄ ¹の処理結果TEMP_T1_4とタスクt₄ ²の処理結果TEMP_T2_4を用いて結合演算の処理を行うタスクである。結合演算の検索元にTEMP_T2_4を使用するので、処理結果TEMP_T2_4に対して処理を行うタスクとして新たにグループG10を作成して、グループG10にタスクt₄ ³を加えることにする。

最後に、タスクt₅ ²の処理が終了すると、処理ツリーP₅からわかるように、グループG1内のタスクt₅ ¹の処理はすでに終了しているので、新たにタスクt₅ ³の処理を始めることができるようになる。タスクt₅ ³はタスクt₅ ¹の処理結果TEMP_T1_5とタスクt₅ ²の処理結果TEMP_T2_5を用いて結合演算の処理を行うタスクである。結合演算の検索元にTEMP_T2_5を使用するので、処理結果TEMP_T2_5に対して処理を行うタスクとして新たにグループG11を作成して、グループG11にタスクt₅ ³を加えることにする。
以上のことをまとめると、グループG4内のタスクt₁ ⁹，t₄ ²，t₅ ²の処理が終了することによって見出されたタスクt₄ ³，t₅ ³を次のようにグループに分けすることになる。タスクt₄ ³の処理結果は、クエリーQ₄の最終の処理結果となるので、RESULT_Q4で表わすことにする。タスクt₅ ³の処理結果は、クエリーQ₅の最終の処理結果となるので、RESULT_Q5で表わすことにする。
TEMP_T2_4：グループ G10＝{t₄ ³}
(t₄ ³)：RESULT_Q4←TEMP_T1_4 |X|_SSN=ESSNTEMP_T2_4
TEMP_T2_5：グループ G11＝{t₅ ³}
(t₅ ³)：RESULT_Q5←TEMP_T1_5 |X|_SSN=ESSNTEMP_T2_5

［（ｅ）グループG5の処理］
グループG4の処理が終了すると、次はグループG5の処理を行うことになる。前述したように、グループG5内のタスクは次のようなものである。
TEMP_T1_2：グループ G5＝{t₂ ²}
(t₂ ²)：TEMP_T2_2←π_{SSN,LNAME,BDATE}TEMP_T1_2
グループG5には１つのタスクt₂ ²しか存在しておらず、タスクt₂ ²はタスクt₂ ¹の処理結果TEMP_T1_2に対して射影演算の処理を行うタスクである。このようにグループに１つのタスクしか存在してしない場合は、グループG5内のタスクt₂ ²を直接処理することになる。
タスクt₂ ²の処理が終了すると、図４−２の処理ツリーP₂からわかるように、グループG9内のタスクt₂ ⁵の処理が終了しておらず、グループに集められていないタスクt₂ ⁶，t₂ ⁷の処理も終了していないので、新たに処理できるタスクは見出されないのでグループは作成されない。

グループG5の処理を終わると、次はグループG6の処理を行うことになる。グループG6には、合成選択演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1に対して処理を行うタスクが集められているので、詳しく説明することにする。

ここまで扱ってきたタスク処理は、データベースのリレーションEMPLOYEE，DEPARTMENT，PROJECT，WORKS_ONなどデータベースのリレーションに対するタスク処理であった。次に、データベースのリレーションではなく、合成関係演算タスクの処理結果として得られたリレーションに対するタスク処理を取り上げて説明することにする。

［（ｆ）グループG6の処理（合成関係演算タスクの処理結果として得られたリレーションに対するタスク処理）］
マルチオペレーション・プロセッシングを使用してグループG6内のタスクt₁ ⁴，t₃ ³，t₆ ⁴の処理を一度に行うことにする。前述したように、グループG6内のタスクは次のようなものである。
TEMP_SG1_G1：グループ G6＝{t₁ ⁴,t₃ ³,t₆ ⁴}
(t₁ ⁴)：TEMP_T4_1←π_{SSN,LNAME,DNUM} TEMP_T3_1
(t₃ ³)：TEMP_T3_3←π_{SSN,FNAME,LNAME,DNUM} TEMP_T2_3
(t₆ ⁴)：TEMP_T4_6←π_{FNAME,LNAME,DNUM} TEMP_T3_6

［（ｆ−１）各タスクのアクセスプラン］
スタティック・マルチオペレーション・プロセッシングの処理方法にもとづいて、グループG6内の各タスクt₁ ⁴，t₃ ³，t₆ ⁴に対してアクセスプランを作成する。タスクt₁ ⁴の処理に用いられる仮想リレーションTEMP_T3_1，タスクt₃ ³の処理に用いられる仮想リレーションTEMP_T2_3，タスクt₆ ⁴の処理に用いられる仮想リレーションTEMP_T3_6からそれぞれタスクがアクセスするブロックを調べることになる。前述したように、仮想リレーションTEMP_T3_1，TEMP_T2_3，TEMP_T3_6には、合成選択演算タスクt_G1 ^SG1の処理結果TEMP_SG1_G1を共有するブロックの番号とアドレスがすでに記録してあるので、事前にどのブロックをアクセスしたらよいかがわかる。タスクt₁ ⁴，t₃ ³，t₆ ⁴のアクセスプランは次のようになる。
plan(t₁ ⁴)：TEMP_SG1_G1のブロックb₁,b₂,b₃をアクセスして射影演算の処理を行う。
plan(t₃ ³)：TEMP_SG1_G1のブロックb₄をアクセスして射影演算の処理を行う。
plan(t₆ ⁴)：TEMP_SG1_G1のブロックb₂,b₃をアクセスして射影演算の処理を行う。

［（ｆ−２）各タスクの処理コスト］
アクセスプランをもとに各タスクの処理コストを計算すると、次のように表すことができる。
タスクt₁ ⁴の処理コスト：cost(t₁ ⁴)＝3
タスクt₃ ³の処理コスト：cost(t₃ ³)＝1
タスクt₆ ⁴の処理コスト：cost(t₆ ⁴)＝2
タスクt₁ ⁴の処理コストは、リレーションTEMP_SG1_G1からブロックの相対アドレスが0，256，512である3つのブロックb₁，b₂，b₃をアクセスして射影演算の処理を行う処理コストなので3である。
タスクt₃ ³の処理コストは、リレーションTEMP_SG1_G1からブロックの相対アドレスが768であるブロックb₄をアクセスして射影演算の処理を行う処理コストなので1である。
タスクt₆ ⁴の処理コストは、リレーションTEMP_SG1_G1からブロックの相対アドレスが256，512である2つのブロックb₂，b₃をアクセスして射影演算の処理を行う処理コストなので2である。以上のように処理コストを計算すると、処理コストをもとにグループ内のタスクを処理コストの小さい順番で並べ替えると次のようになる。
sort(t₁ ⁴,t₃ ³,t₆ ⁴) ⇒ (t₃ ³,t₆ ⁴,t₁ ⁴)

［（ｆ−３）各タスクに対応するブロック集合］
仮想リレーションに記録してある情報をもとに、タスクt₃ ³，t₆ ⁴，t₁ ⁴がリレーションTEMP_SG1_G1からアクセスする必要のあるブロックを調べて、各タスクに対応するブロック集合B₃ ³，B₆ ⁴，B₁ ⁴に集めると、次のようになる。
タスクt₃ ³に対して：B₃ ³＝{b₄}
タスクt₆ ⁴に対して：B₆ ⁴＝{b₂,b₃}
タスクt₁ ⁴に対して：B₁ ⁴＝{b₁,b₂,b₃}

［（ｆ−４）アクセスすべきブロック（共通ブロック）の順位の決定］
以上のように、各タスクに対応するブロック集合を見出した後に、処理コストの小さいタスクから処理コストの大きいタスクへと順番に、すなわちタスクt₃ ³，t₆ ⁴，t₁ ⁴の順番に各タスクに対応するブロック集合の和集合を求めていくことにする。
まず、TB₀＝{}（空集合）として、TB₀とタスクt₃ ³に対応するブロック集合B₃ ³と和集合TB₃ ³を求める。次に、このTB₃ ³とタスクt₆ ⁴に対応するブロック集合B₆ ⁴との和集合TB₆ ⁴を求める。さらに、このTB₆ ⁴とタスクt₁ ⁴に対応するブロック集合B₁ ⁴との和集合TB₁ ⁴を求めると次のようになる。この場合、和集合を求めるに当たっては、新たに加える集合は和集合の中で最後に加えていくものとする。
TB₀＝{}
タスクt₃ ³に対応する集合B ₃ ³ との和集合：TB₃ ³＝TB₀∪B₃ ³＝{b₄}
タスクt₆ ⁴に対応する集合B ₆ ⁴ との和集合：TB₆ ⁴＝TB₃ ³∪B₆ ⁴＝{b₄,b₂,b₃}
タスクt₁ ⁴に対応する集合B ₁ ⁴ との和集合：TB₁ ⁴＝TB₆ ⁴∪B₁ ⁴＝{b₄,b₂,b₃,b₁}

集合TB₁ ⁴からリレーションTEMP_SG1_G1内のブロックをb₄，b₂，b₃，b₁の順番でアクセスしていけばよいことがわかる。前述したブロック集合B₃ ³，B₆ ⁴，B₁ ⁴の中に含まれているブロックを見ると、ブロックb₄は、タスクt₃ ³を処理するために使用され、ブロックb₂は、タスクt₆ ⁴，t₁ ⁴を処理するために使用され、ブロックb₃は、タスクt₆ ⁴，t₁ ⁴を処理するために使用され、ブロックb₁は、タスクt₁ ⁴を処理するために使用されることがわかる。これらのブロックを共通ブロックとして扱うことにすると、これらの共通ブロックを必要とするタスクを共通ブロック上で一度に処理することができる。以上のことをまとめると次のような表になる。

[(ｆ−５)共通ブロックでのタスクの処理］
以上のように、それぞれの共通ブロックでどのようなタスクが処理されるかを見出すためには、タスクt₃ ³，t₆ ⁴，t₁ ⁴に対して作成されたブロック集合B₃ ³，B₆ ⁴，B₁ ⁴の情報にもとづいて、次に記述するような手順を用いればよい。
最初に、ブロックの相対アドレスが768であるブロックb₄をディスクからアクセスして、ブロックb₄内のデータをメインメモリに読み込み、グループ内のタスクt₃ ³，t₆ ⁴，t₁ ⁴がブロックb₄で処理を行う必要があるかどうかを調べるため、ブロックb₄を集合{b₄}として表わし、ブロック集合B₃ ³，B₆ ⁴，B₁ ⁴とそれぞれ積集合（intersection）を求める。
タスクt₃ ³に対して：B₃ ³∩{b₄}＝{b₄}
タスクt₆ ⁴に対して：B₆ ⁴∩{b₄}＝{}
タスクt₁ ⁴に対して：B₁ ⁴∩{b₄}＝{}

タスクt₆ ⁴，t₁ ⁴を除くタスクt₃ ³に対する集合の積が空集合{}ではないため、メインメモリに読み込んだブロックb₄内の各レコードに対してタスクt₃ ³の処理を行う。ブロックb₄での処理が終了するとブロックb₄を再びアクセスする必要がなくなるため、集合B₃ ³と集合{b₄}との差集合（difference）を求めて、求めた差集合の値をB₃ ³⁽¹⁾とすると次のようになる。
タスクt₃ ³に対して：B₃ ³−{b₄}＝{}＝B₃ ³⁽¹⁾
集合B₃ ³⁽¹⁾が空集合{}になりタスクt₃ ³の処理が終了したことがわかる。
次に、ブロックの相対アドレスが256であるブロックb₂をディスクからアクセスして、ブロックb₂内のデータをメインメモリに読み込み、すでに処理の済んだタスクt₃ ³を除くグループ内のタスクt₆ ⁴，t₁ ⁴がブロックb₂で処理を行う必要があるかどうかを調べるために、ブロックb₂を集合{b₂}として表し、集合{b₂}とブロック集合B₆ ⁴，B₁ ⁴との間でそれぞれ積集合を求めると次のようになる。
タスクt₆ ⁴に対して：B₆ ⁴∩{b₂}＝{b₂}
タスクt₁ ⁴に対して：B₁ ⁴∩{b₂}＝{b₂}

タスクt₆ ⁴，t₁ ⁴に対する積集合が{b₂}となり、タスクt₆ ⁴，t₁ ⁴がメインメモリに読み込んだブロックb₂で処理を行うことが必要となり、ブロックb₂は共通ブロックとなり、共通ブロックb₂でタスクt₆ ⁴，t₁ ⁴の処理を行うことになる。共通ブロックであるブロックb₂でのタスクの処理が終了すると、ブロックb₂を再びアクセスする必要がなくなるので、集合B₆ ⁴，B₁ ⁴と集合{b₂}との差集合を求める。得られた差集合の値をB₆ ⁴⁽¹⁾，B₁ ⁴⁽¹⁾とすると、次のようになる。
タスクt₆ ⁴に対して：B₆ ⁴−{b₂}＝{b₃}＝B₆ ⁴⁽¹⁾
タスクt₁ ⁴に対して：B₁ ⁴−{b₂}＝{b₁,b₃}＝B₁ ⁴⁽¹⁾

次に、ブロックの相対アドレスが512であるブロックb₃をディスクからアクセスして、ブロックb₃内のデータをメインメモリに読み込み、すでに処理の済んだタスクt₃ ³を除くグループ内のタスクt₆ ⁴，t₁ ⁴がブロックb₃で処理を行う必要があるかどうかを調べるために、ブロックb₃を集合{b₃}として表し、集合{b₃}とブロック集合B₆ ⁴⁽¹⁾，B₁ ⁴⁽¹⁾との間でそれぞれ積集合を求めると次のようになる。
タスクt₆ ⁴に対して：B₆ ⁴⁽¹⁾∩{b₃}＝{b₃}
タスクt₁ ⁴に対して：B₁ ⁴⁽¹⁾∩{b₃}＝{b₃}
タスクt₆ ⁴，t₁ ⁴に対する積集合が{b₃}となり、タスクt₆ ⁴，t₁ ⁴がメインメモリに読み込んだブロックb₃で処理を行うことが必要となり、ブロックb₃は共通ブロックとなり、共通ブロックb₃でタスクt₆ ⁴，t₁ ⁴の処理を行うことになる。共通ブロックであるブロックb₃でのタスクの処理が終了すると、ブロックb₃を再びアクセスする必要がなくなるので、集合B₆ ⁴⁽¹⁾，B₁ ⁴⁽¹⁾と集合{b₃}との差集合を求める。得られた差集合の値をB₆ ⁴⁽²⁾，B₁ ⁴⁽²⁾とすると、次のようになる。
タスクt₆ ⁴に対して：B₆ ⁴⁽¹⁾−{b₃}＝{}＝B₆ ⁴⁽²⁾
タスクt₁ ⁴に対して：B₁ ⁴⁽¹⁾−{b₃}＝{b₁}＝B₁ ⁴⁽²⁾

この結果、集合B₆ ⁴⁽³⁾が空集合{}になりタスクt₆ ⁴の処理が終了したことがわかる。この段階で、グループに残ったタスクはt₁ ⁴のみとなるので、リレーションTEMP_SG1_G1から残ったブロックb₁をアクセスしてタスクt₁ ⁴の処理を行い、タスクt₁ ⁴の処理が終了するとグループ内すべてのタスクの処理が終了することになる。

以上のように、リレーションTEMP_SG1_G1内のブロックをb₄，b₂，b₃，b₁の順番でアクセスすることによって、処理コストの小さいタスクからt₃ ³，t₆ ⁴，t₁ ⁴の順番でタスク処理が終了することがわかる。図１０は、スタティックマルチオペレーション・プロセッシングを使用してグループG6の処理を行っている様子を表している。プロセス(801)は、リレーションTEMP_SG1_G1(800)内ブロックをb₄，b₂，b₃，b₁の順番でアクセスして、タスクt₃ ³，t₆ ⁴，t₁ ⁴の処理を一度に行い、処理結果をTEMP_T3_3，TEMP_T4_6，TEMP_T4_1に書き込んでいる。

［（ｆ−６）新たなグループの作成］
マルチオペレーション・プロセッシングを使用してグループG6内のタスクが、タスクt₃ ³，t₆ ⁴，t₁ ⁴の順番で終了すると、図４−１〜図４−３の処理ツリーからトポロジカルソートの順番で新たに処理できるタスクを見出していくことになる。
最初に、タスクt₃ ³の処理が終了すると、処理ツリーP₃からわかるように新たにタスクt₃ ⁴の処理を始めることができるようになる。タスクt₃ ⁴は、タスクt₃ ¹の処理結果TEMP_T1_3とタスクt₃ ³の処理結果TEMP_T3_3を用いた結合演算の処理を行うタスクであり、TEMP_T1_3を検索先のリレーションとして使用し、TEMP_T3_3を検索元のリレーションとして使用することになるので、検索元のリレーションであるTEMP_T3_3に対して処理を行うタスクとして新たにグループG12を作成してグループG12にタスクt₃ ⁴を加える。

次に、タスクt₆ ⁴の処理が終了すると、処理ツリーP₆からわかるように、グループG7内のタスクt₆ ²の処理が終了していないので、新たに処理できるタスクは見出されないので新たなグループは作成されない。
最後に、タスクt₁ ⁴の処理が終了すると、処理ツリーP₁からわかるようにグループG8内のタスクt₁ ²の処理が終了していないので新たなグループは作成されない。
以上のことをまとめると、グループG6内のタスクt₃ ³，t₆ ⁴，t₁ ⁴の処理が終了することによって見出されたタスクt₃ ⁴を次のようにグループG12に加えることになる。
TEMP_T3_3：グループ G12＝{t₃ ⁴}
(t₃ ⁴)：TEMP_T4_3←TEMP_T1_3 |X|_DNUMBER=DNUMTEMP_T3_3

このようにして、グループの処理を繰り返して行っていくうちに、図４−１〜図４−３に示した処理ツリー内のタスクが次第に終了していき、処理ツリー内すべてのタスクの処理が終了すると、与えられたすべてのクエリー処理は終了することになる。

［３．実験の処理結果］
合成関係演算を利用したマルチオペレーション・プロセッシングを用いたクエリー・プロセッサが、マルチオペレーション・プロセッシングを用いたクエリー・プロセッサ及び従来のクエリー・プロセッサ（ＭｙＳＱＬ Ｖｅｒ.３）よりも数多くのクエリーを早く処理することを証明するために、独自に開発したデータベースマネージメントシステム（ＤＢＭＳ）のソフトウェアＭＯＰ−ＤＢに新たに合成関係演算を利用したマルチオペレーション・プロセッシングの処理を行うことができる機能を追加した。ＭＯＰ−ＤＢは、ＭｙＳＱＬなど市場で幅広く使われているデータベースシステムよりも数多くのクエリーを高速に処理することを目的とし、ＳＱＬのインタープリタ、クエリーの最適化、トランザクションの同時処理、データを格納するストレージシステムなどデータベースマネージメントシステム（ＤＢＭＳ）に必要な十分な機能を備えたソフトウェアである。合成関係演算を利用したマルチオペレーション・プロセッシングの実験を行うにあたって、合成関係演算を利用したマルチオペレーション・プロセッシングには、スタティックマルチオペレーション・プロセッシングを使用することにした。

独自に開発したＭＯＰ−ＤＢに、合成関係演算を利用したスタティックマルチオペレーション・プロセッシングを用いたクエリー処理を追加したことによって、ＭＯＰ−ＤＢは合成関係演算を利用したスタティックマルチオペレーションを用いたクエリー処理、スタティックマルチオペレーション・プロセッシングを用いたクエリー処理、ダイナミックマルチオペレーション・プロセッシングを用いたクエリー処理を行うことができ、これらのクエリー処理方法を自由に選択して実行することが可能になった。
次にＭＯＰ−ＤＢを使用して、これらのクエリー処理方法によるクエリーの処理速度をそれぞれ調べた。さらに市場で幅広く使用されているＭｙＳＱＬのバージョン３と比較するために、共通のクエリー処理を行ってＭＯＰ−ＤＢとＭｙＳＱＬの処理速度を調べた。

ＭＯＰ−Ｄを用いてクエリー処理のテストを行うには、数多くのレコードを格納した十分に大きいデータベースが必要なため、Windows XP Professional(R)を搭載した一般のエントリーレベルのパーソナルコンピューター（１つのCeleron CPU 2.53GHzプロセッサ、512MBメインメモリ、１つの145GBディスク）上に、図１１のリレーションEMPLOYEE，DEPARTMENT，WORKS_ON，PROJECTと４つのリレーションから構成されるデータベースを作成し、それぞれのリレーションに１０万件ずつレコードを格納し、合計４０万件ほどのレコードをデータベースに加えた。クエリーを効率よく高速に処理するには、リレーションにインデックスが必要であるため、リレーションEMPLOYEE(1101)の主属性SSNに対して主インデックス(1100)を作成し、２次属性PHONEに対して２次インデックス(1102)を作成した。リレーションDEPARTMENT(1105)では、主属性DNUMBERに対して主インデックス(1104)を作成し、２次属性DPHONEに対して２次インデックス(1106)を作成した。リレーションPROJECT(1108)では、主属性PNUMBERに対して主インデックス(1107)を作成した。同様に、ＭｙＳＱＬバージョン３を用いた場合にも、４個のリレーションから構成される共通のデータベースを作成し、ＭＯＰ−ＤＢと同様に、データベース内のリレーションに対してインデックスを加えた。

次に、データベースサーバーに問い合わせるクエリーは、それぞれのクエリー・プロセッサの処理能力を最大限に利用するために、複雑な検索処理を必要とする数多くの異なるクエリーをSQLで記述した。それらのクエリーは次のような条件や特性を持つものである。

（１）問い合わせるクエリーには、同じクエリーが１つとして含まれないようにするため、すべてのクエリーの検索条件は異なるものにした。また、各クエリーには、演算、属性、変数からなる検索条件をブール演算のＡＮＤ，ＯＲを組み合わせて、さらに複雑な検索条件を持たせて絞込み検索を行うようにした。

（２）クエリー・プロセッサによって十分な結合演算処理が行われるように、各クエリーには２つ以上の結合演算を含むようにした。また、クエリー・プロセッサによって必ず検索結果が得られるように、各クエリーには検索条件がゼロにならない検索条件を与えた。

（３）クエリー・プロセッサによってあらゆる種類の処理結果が得られるように、１０００件以下の処理結果が得られるクエリー、１０００件から１万件の処理結果が得られるクエリー、１万件から５万件の処理結果が得られるクエリー、５万件から１０万件の処理結果が得られるクエリーをそれぞれ十分な数ほど（それぞれ２５パーセントずつ）データベースに問い合わせた。

（４）クエリー・プロセッサによってインデックスを用いた検索が行われるように、検索条件に主インデックスを利用するクエリー、２次インデックスを利用するクエリー、主インデックスと２次インデックスの両方を利用するクエリーを与えた。また、インデックスを利用しないクエリーがインデックスを利用するクエリーと交わって処理されるように、選択条件に主インデックスと２次インデックスの両方を利用しないクエリーも与えた。

ＭＯＰ−ＤＢの合成関係演算を利用したスタティックマルチオペレーション・プロセッシングを用いたクエリー処理、ダイナミックマルチオペレーション・プロセッシングを用いたクエリー処理、スタティックマルチオペレーション・プロセッシングを用いたクエリー処理、及びＭｙＳＱＬバージョン３の処理速度を調べるために、データベースサーバーに検索処理を要求するクライアントプログラムを用意し、クライアントプログラムから数多くのＳＱＬで記述されたクエリーをデータベースサーバーに問い合わせて、データベースサーバー上のクエリー・プロセッサによってすべてのクエリーが処理されて、検索結果がクライアントプログラムに返されるまでの時間を測定する方法を用いた。クライアントコンピューターとデータベースサーバーとの間の通信速度の影響を避けるために、直接、データベースサーバー上でクライアントプログラムを起動させて、検索処理結果が得られるようにした。データベースに問い合わせるために作成したクエリーの数は、１００件、２００件、３００件、４００件、５００件、６００件、７００件、８００件、９００件、１０００件となるように、徐々に件数を増加させてクエリーの処理速度を測定した。同様に、ＭｙＳＱＬバージョン３に対しても、上述した件数と同数のクエリー数を用いて、ＭｙＳＱＬのクエリーの処理速度を測定して、ＭｙＳＱＬの処理速度とＭＯＰ−ＤＢを用いた合成関係演算を利用したスタティックマルチオペレーション・プロセッシング、ダイナミックマルチオペレーション・プロセッシング、スタティックマルチオペレーション・プロセッシングとの処理速度を比較した。

図１２は、ＭＯＰ−ＤＢの合成関係演算を利用したスタティックマルチオペレーション・プロセッシング、ダイナミックマルチオペレーション・プロセッシング、スタティックマルチオペレーション・プロセッシング、及びＭｙＳＱＬのバージョン３に対して、数多くのクエリーを問い合わせたときに、クエリー数とクエリーの処理速度の関係を比較した結果を表（図１２（ａ）参照）とグラフ（図１２（ｂ）参照）で表わしたものである。

図１２（ａ），（ｂ）に示した処理結果から、クエリー数が１００件から１０００件までの件数において、全体的に、合成関係演算を利用したスタティックマルチオペレーション・プロセッシングが最も早く、次にダイナミックマルチオペレーション・プロセッシングの処理速度が速く、その次にスタティックマルチオペレーション・プロセッシングとなり、ＭｙＳＱＬの処理速度が一番遅いことがわかる。

合成関係演算を利用したスタティックマルチオペレーション・プロセッシングは、クエリー数が１００件から５００件までは、ダイナミックマルチオペレーション・プロセッシングよりも平均して1.64倍の処理速度が得られ、スタティックマルチオペレーション・プロセッシングよりも平均して1.76倍の処理速度が得られ、ＭｙＳＱＬバージョン３の処理速度よりも平均して6.34倍の処理速度が得られ、クエリー数が６００件から１０００件まででは、ダイナミックマルチオペレーション・プロセッシングよりも平均して1.65倍の処理速度が得られ、スタティックマルチオペレーション・プロセッシングよりも平均して、1.79倍の処理速度が得られ、ＭｙＳＱＬバージョン３の処理速度よりも平均して6.47倍の処理速度が得られた。

データベースシステムのアーキテクチャの構成例を示す図である。 クエリーを処理するフローチャートである。 実施形態で使用するデータベースのリレーションDEPARTMENTを示す図である。 実施形態で使用するデータベースのリレーションEMPLOYEEを示す図である。 実施形態で使用するデータベースのリレーションPROJECT，WORKS_ONを示す図である。 処理ツリーP_１を示す図である。 処理ツリーP₂，P₃，P₄を示す図である。 処理ツリーP₅，P₆を示す図である。 タスクのグループ分け及びサブグループ分けを説明する図である。 合成選択演算の最適化を説明する図である。 合成関係演算を利用したスタティックマルチオペレーション・プロセッシングを説明する図である。 合成選択演算の処理結果を共有するための手順を説明する図である。 合成選択演算の処理結果を共有するための手順（続き）を説明する図である。 合成関係演算を利用したスタティックマルチオペレーション・プロセッシングを説明する図である。 合成関係演算タスクの処理結果として得られたリレーションに対するスタティックマルチオペレーション・プロセッシングを説明する図である。 実際に処理を行ったデータベースのリレーションを示す図である。 実験の処理結果を示す図である。

データベースシステムのアーキテクチャの構成例を示す図である。 クエリーを処理するフローチャートである。 実施形態で使用するデータベースのリレーションDEPARTMENTを示す図である。 実施形態で使用するデータベースのリレーションEMPLOYEEを示す図である。 実施形態で使用するデータベースのリレーションPROJECT，WORKS_ONを示す図である。 処理ツリーP_１を示す図である。 処理ツリーP₂，P₃，P₄を示す図である。 処理ツリーP₅，P₆を示す図である。 タスクのグループ分け及びサブグループ分けを説明する図である。 合成選択演算の最適化を説明する図である。 合成関係演算を利用したスタティックマルチオペレーション・プロセッシングを説明する図である。 合成選択演算の処理結果を共有するための手順を説明する図である。 合成選択演算の処理結果を共有するための手順（続き）を説明する図である。 合成関係演算を利用したスタティックマルチオペレーション・プロセッシングを説明する図である。 合成関係演算タスクの処理結果として得られたリレーションに対するスタティックマルチオペレーション・プロセッシングを説明する図である。 実際に処理を行ったデータベースのリレーションを示す図である。 処理結果を示す図である。

Claims (6)

1. 合成関係演算を利用したマルチオペレーション・プロセッシングを用いたデータベースのクエリー処理システムであって、
   前記クエリーを関係代数による処理ツリーに変換する処理ツリー変換手段と、
   前記処理ツリーから、トポロジカル・ソートにより、関係代数を他の関係代数の結果に依存しないで実施できる順番に、タスクとして取り出すタスク取り出し手段と、
   前記取り出したタスクを、前記データベースのリレーションごとにグループ分けするグループ分け手段と、
   グループ分けされた前記タスクに対して、共通部分式を持つタスクをさらにサブグループに集め、合成関係演算タスクを作成する合成関係演算作成手段と、
   前記グループ分けされたタスクごとに、作成された前記合成関係演算タスクとサブグループに集まらないタスクとに対してマルチオペレーション・プロセッシングを行うマルチオペレーション・プロセッシング手段と、
   グループ内の前記合成関係演算タスクの処理結果として得られたリレーションに対して、前記合成関係演算に含まれる個々のタスクが、そのリレーションのレコード及び／又は属性を部分的に共有するように、格納位置による仮想リレーションを作成する仮想リレーション作成手段とを備え、
   前記グループ分け手段は、前記合成関係演算タスクの処理結果として得られたリレーションごとにも、タスクをグループ分けすることを特徴とするクエリー処理システム。
2. 請求項１記載のクエリー処理システムにおいて、
   前記合成関係演算作成手段は、サブグループに集めた複数の選択演算タスクで使用する属性名と属性数が等しいときに、それらの属性の中の１つの属性に関する選択条件だけが異なった条件かまたは同じ条件であり、それ以外の属性に関する選択条件はまったく同じであるならば、それらの選択条件をブール演算のＯＲを使用して接続し、接続した選択条件から選択範囲の重複した部分を取り除くために、簡潔化して最適化した選択条件を作成し、その選択条件を用いて複数の選択演算タスクの合成関係演算を作成することを特徴とするクエリー処理システム。
3. 請求項１記載のクエリー処理システムにおいて、
   前記合成関係演算作成手段は、サブグループに集めた複数の射影演算タスクが、共通のリレーションに対して射影演算の処理を行うならば、これらの射影演算タスクの属性の和集合を求めて得られた属性を用いて、複数の射影演算タスクの合成関係演算を作成することを特徴とするクエリー処理システム。
4. 請求項１〜３のいずれかに記載のクエリー処理システムにおいて、
   前記仮想リレーション作成手段は、仮想リレーションのレコードに対してタスクが検索処理を行う場合、仮想リレーションが部分的に共有するリレーションの検索に使用する属性に対して、インデックスを作成することを特徴とするクエリー処理システム。
5. 請求項１〜４のいずれかに記載の合成関係演算を利用したマルチオペレーション・プロセッシングを用いたデータベースのクエリー処理システムの各機能を、コンピュータ・システムに実現させるためのプログラム。
6. 請求項１〜４のいずれかに記載のマルチオペレーション・プロセッシングを用いたデータベースのクエリー処理システムの各機能を、コンピュータ・システムに実現させるためのプログラムを記録した記録媒体。