JP2008234495A - Query processing system of database using multi-operation processing using synthetic relational operation - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To propose a method for improving the processing speed of a query. <P>SOLUTION: When the inquiry of a query is input (S110), it is converted into a processing tree configured by a relational operation (S120), and a directly processable task is found out (S130). When the task is found out, whether or not a group accessing a common relation exists in a group column is checked (S140), and when the group accessing the common relation exists in the group column, the task is added to the group (S150). When any group does not exist, the new group is prepared (S160). The tasks having a common partial formula in the group are gathered in a sub-group (S170), and when the tasks are gathered in the sub-group, a composite relational operation task is prepared based on the tasks in the sub-group (S180). The processing of the composite relational operation task in the group is performed at once (S190). When the processing of the composite relational operation ends, the virtual relation is prepared for the tasks in the sub-group, and the relation acquired as the processing result of the composite relational operation task is partially shared (S200). <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a database query processing system, and more particularly to query processing using multi-operation processing using a composition relational operation.

  When a large number of queries are inquired to the database management system (DBMS) at a time, the database management system performs each inquiry processing by using a transaction concurrent processing control function. A search-only transaction is called a query, and the database management system processes the queried query separately, but this method has the following problems.

  Problem (1): In the query processing method by the conventional database management system, when many queries process a common relation, the same data is read from the disk into the main memory and accessed many times. Each time access is made, the data in the block is repeatedly read into the main memory for processing. For this reason, there is a problem that the processing speed of the query is not efficient and the query processing speed is lowered.

  Problem (2): In the query processing method according to the conventional database management system, a task processing result relation which is an intermediate result of a query is created on a disk every time task processing in a query is performed. In the processing results of each task, the selection ranges of records and attributes overlap, so many relations of processing results that overlap the selection ranges of records and attributes are created on the disk. For this reason, there are problems that the number of times the disk is accessed increases and the query processing speed decreases.

  Problem (3): The conventional query processing method using the database management system uses a join method such as a hash join when processing a join operation included in a query. For this reason, each time a join operation is performed, a record in the search relation used for the join operation is accessed from the disk, and a hash table (hash table is indexed to the record in the search relation in the main memory). This causes a problem that the number of times the disk is accessed increases and the query processing speed decreases.

  In addition, since the relation of the search destination used for each join operation is different, it is necessary to create a separate hash table for each join operation. If many hash tables are created in the main memory at once, the main memory There is a problem that sufficient space cannot be secured in the memory and the query processing speed is reduced.

(Problems of calculation and result caching)
In order to improve the query processing speed by reducing the number of times to access the disk, queries with many queries, query processing results, operations included in queries (relational algebra such as selection operations, projection operations, and join operations) and operations A method of temporarily storing (caching) the processing result (intermediate result of the query) on a disk is often used. When there is a query query from a user, the database management system checks whether the same query processing result as the query that was queried is stored on disk and, if so, the query processing. Without processing, the processing result of the stored query is returned to the user as it is. In addition, even if the query is different, if the processing result of the same operation as the operation included in the query is stored on the disk, the database management system does not process the operation and does not process the existing operation. The query is processed using the result.

  The purpose of this method is to increase the query processing speed by increasing the processing result of the query to be saved and the processing result of the calculation, without repeating the same query or the processing of the calculation. However, this method requires that the query that was queried and the operation included in the query be the same as those stored on the disk, so if the query or operation is different, use the saved processing results. It is not possible. In this method, when a new record is added to the database and the database is updated, the stored processing results become obsolete, so the database management system discards the obsolete processing results. There must be. Therefore, if the database is updated frequently, this method becomes inefficient because an old processing result must be discarded. In order to maintain query processing speed, database management systems such as Microsoft's SQL server do not immediately discard old query processing results, but return old processing results to the user for a while. ing.

(Problem of caching to main memory)
Another way to improve query processing speed by reducing the number of disk accesses is to temporarily store (cache) a copy of the frequently accessed blocks on the disk to process the query. Method is used. In this method, when a user queries a query, the database management system checks to see if a copy of the block accessed from disk is stored in main memory to process the query. Then, use a copy in the main memory.
The purpose of this method is to increase the capacity of blocks stored in the main memory, thereby reducing the number of times the disk is accessed and improving the query processing speed.

However, this method requires that the block on disk and the replica in main memory be the same, so when changing data in a block, both the block on disk and the replica in main memory must be updated. There must be. In addition, when performing a linear search (scan) of a database relation that has several gigabytes (GB) to process a query, most blocks other than the blocks stored in the main memory are accessed from the disk. It will not be effective.
In addition, since the operating system itself performs such memory management, if the capacity of the block that the database management system stores in the main memory is increased, the block that should have been stored in the main memory may be changed by the operating system. There is a problem that the query processing speed is reduced due to movement to virtual memory (disk).

(Problems of query processing pipelining)
As a method of improving the query processing speed by reducing the number of times the disk is accessed without creating a relation of the task processing results that are the intermediate results of the query on the disk, a method of pipelining query processing is used. It is done.
Query processing is pipelined in a computer system that has multiple microprocessors. Multiple task processes included in a query are pipelined using multiple microprocessors, and each task process is parallelized. It is a method of processing. In this method, the processing result of each task included in the query is streamed, and the next task processing for the processing result of the partially completed task is performed without waiting for the individual task processing to be completed completely. Is going to go. However, task processing that can be pipelined is limited to tasks such as selection operations and projection operations. Tasks such as join operations are processed only after the task processing performed before the join operation is completed. It can't be started, so it can't be pipelined. Also, the method of pipelining query processing requires a computer system equipped with a plurality of microprocessors, and is not effective in a computer system having only one microprocessor.

References referred to by the inventors are described below.
Queries with many queries and query processing results, relational algebra included in queries (selection, projection, join operations, etc.) and processing results (intermediate results of queries) are temporarily saved to disk (caching) Non-Patent Documents 1 to 6 described below are listed as what is described.
Non-patent documents 7 to 11 describe that a copy of a block on a disk to be accessed for processing a query is temporarily stored (cached) in a main memory.
Non-patent document 12 describes the query processing pipeline.
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, DC, 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

The solutions described above have been adopted in many database management systems, but are not always efficient due to problems.
In addition to these solutions, the present invention proposes a method for improving the query processing speed by reducing the number of times the disk is accessed by using a query processing method devised independently.

  In order to achieve the above object, the present invention provides a database query processing system using multi-operation processing using a composition relational operation, wherein the query is converted into a processing tree based on a relational algebra. Means for extracting relational algebra from the processing tree as a task by topological sorting in an order in which the relational algebra can be implemented without depending on the result of other relational algebra, and the extracted task for each relation of the database. A grouping means for grouping, a task having common sub-expressions for the grouped tasks, and a synthetic relational calculation creating means for creating a synthetic relational calculation task by collecting the tasks having a common sub-expression into the subgroup, and the grouped For each task, the created composite performance is created. Multi-operation processing means for performing multi-operation processing on tasks and tasks that do not gather in a subgroup, and the relation obtained as a result of the processing of the composite relation calculation task in the group Each of the included tasks includes virtual relation creating means for creating a virtual relation based on the storage position so that the records and / or attributes of the relation are partially shared.

When the attribute name and the number of attributes used in the plurality of selection calculation tasks collected in the subgroup are equal, the composition relation calculation creation means is a condition in which only a selection condition relating to one attribute among the attributes is different or If the selection conditions for the other attributes are exactly the same, connect the selection conditions using a Boolean OR, and remove the duplicated part of the selection from the connected selection conditions In addition, it is preferable to create a selection condition that is simplified and optimized, and to create a composite relation calculation of a plurality of selection calculation tasks using the selection condition.
If the plurality of projection calculation tasks collected in the subgroup perform projection calculation processing on a common relation, the composite relation calculation creation means can obtain the union of the attributes of these projection calculation tasks. It is preferable to create a composition relation calculation of a plurality of projection calculation tasks using the attribute.
The virtual relation creating means may create an index for an attribute used for searching for a relation partially shared by the virtual relation when the task performs a search process on the record of the virtual relation. The grouping means may group the tasks for each relation obtained as a result of the synthesis-related calculation task.
The present invention also relates to a program for causing a computer system to realize each function of the database query processing system using multi-operation processing using the above-described composite relational operation, and a recording medium on which the program is recorded.

Perform query processing more efficiently than query processing using only multi-operation processing by defining common sub-expressions related to unique tasks and performing query processing using multi-operation processing using synthetic relational operations Can now.
In this method, tasks having common sub-expressions in the group are further collected into subgroups, and several tasks collected in the subgroup are replaced with one composite relational calculation task for processing. In addition, each task in the subgroup uses the virtual relation to partially share the relation obtained as a result of the processing of the synthetic relation calculation task. It is no longer necessary to separately create relations of many processing results having overlapping attributes on the disk, reducing the number of times the disk is accessed and improving the query processing speed.

  In addition, when a task performs a search process on a record of a virtual relation, an index is created for the attribute used to search for the relation obtained as a result of the processing of a synthetic relation calculation task partially shared by the virtual relation By doing so, it is possible to share the index with other tasks and perform the search process, and it is possible to reduce the number of times of accessing the disk and to improve the query processing speed.

In addition, by grouping tasks for each relation access area obtained as a result of the processing of the composition-related operation task, task processing can be performed at once on the common block of the relation. The number of accesses can be reduced and task processing can be performed very efficiently.
As can be seen from the actual processing results, it is possible to process many more queries at a higher speed than MySQL.Ver3, which has been widely used so far, and a query processor that used only multi-operation processing. Became.

  As a solution to the problem (1) of the prior art, the present inventor has also proposed "a database query by multi-operation processing" in order to improve the query processing speed by reducing access to a secondary storage device such as a disk. "Improvement of processing" was proposed (see Japanese Patent Application No. 2006-356406). In multi-operation processing, when several tasks operate on a common relation, they are grouped together and an access plan is created for each task in the group. The common block (Common Block) obtained by accessing the relation block in the disk by each task is found, and the tasks collected in the group are processed at once using the common block. is there.

  This method avoids accessing the blocks in the disk for each task and improves the processing speed of the query (the whole task) by processing several tasks at once in the common block Aiming for In carrying out this multi-operation processing, the present inventor, in the above-mentioned application, invented two types of dynamic multi-operation processing (Dynamic Multi-Operation Processing) and static multi-operation processing (Static Multi-Operation Processing). A processing method was proposed.

  Dynamic multi-operation processing creates an access plan for each task in the group, calculates the processing cost of each task from the access plan, refers to the calculated processing cost, and starts from the task with the lowest processing cost. Task processing is performed. In this process, if it is necessary to process other tasks in the group in the block accessed to perform the current task (task with low processing cost), the accessed block becomes a common block. These tasks are processed at once in a block. When the current task processing is finished and the next task with the lowest processing cost is processed in the group, the individual task processing in the group including the current task in the already accessed block has been completed. From the remaining blocks that have not yet been accessed, a block that is required for performing task processing with the next lowest processing cost is accessed. In the accessed block, when other tasks in the group (remaining tasks) need to be processed, the accessed block becomes a common block, and these task processes are performed at a time in the common block. In this way, task processing is repeated for the remaining tasks in the group.

  Static multi-operation creates an access plan from each task in the group, obtains the processing cost of each task from the access plan, refers to the obtained processing cost, and determines the processing cost from the task with the smallest processing cost. The tasks in the group are arranged in order from the largest task. Up to this point, the procedure is the same as that for dynamic multi-operation processing. Then, using the database index, each task in the group examines the blocks that need to be accessed to perform task processing from the blocks in the common relation, and collects them in a block set corresponding to each task. Next, the order of the blocks to be accessed is determined by obtaining the union of the block sets corresponding to each task in accordance with the order from the task with the lowest processing cost to the task with the higher processing cost. According to this order, blocks in a common relation are accessed from the disk, and this block is set as a common block, and task processing within a group that needs to be processed on this block is processed at once. This method performs logical processing of each task included in a query using set theory such as union, product set, and difference set according to the order of blocks to be accessed (common blocks). .

  This time, in order to solve the above problem (1) and to solve the problems (2) and (3), it is possible to efficiently process many queries that have been inquired in the database. We propose multi-operation processing using relational operations. Multi-operation processing using synthetic relational operations is much more than the above-mentioned query processing using multi-operation processing by adding processing methods using synthetic relational operations that are uniquely defined to multi-operation processing. It is a method that processes many tasks at once, reduces disk access, and quickly processes many queries from users.

  Multi-operation processing using composition-related operations, which will be described in detail below, is a query that has been queried by the user. When a query processing tree is created by query optimization, tasks that are points of contact on the processing tree are displayed. In the order of topological sort, a task that can be directly processed without dependency from other tasks is found, and these tasks are divided into groups based on the relation of the database accessed by each task. Next, the tasks in the group are further grouped into subgroups for each common subexpression, and for each subgroup, a composite relation operation task is created based on the tasks in the subgroup, and multi-operation processing is performed. Used to process the tasks in the group including the composition related calculation task at once.

Since the processing result of the composite relational operation task includes all of the processing results of the individual tasks in the subgroup, the task in the subgroup partially uses the relation obtained as the processing result of the composite relational operation task. Will share with you.
In order to show that the processing result of the composite relational calculation task is partially shared, a virtual relation based on the storage position is created for each task in the subgroup, and the processing result of the composite relational calculation task is added to the virtual relation. Record the information you need to share.
If the synthetic relational calculation task is a selection calculation, create a relation that is the processing result arranged by the attribute used in the selection condition, and use the relation name and record of the processing result of the synthetic relational calculation task to be shared as a virtual relation The information such as the storage position (the row range of the record, the number and address of the block in which the record is stored) is recorded.
When the composition relation calculation task is a projection calculation, information such as the relation name of the processing result of the composition relation calculation task to be shared and the storage position (column number) of the attribute is recorded as a virtual relation.
By recording these pieces of information in the virtual relation, a task that performs processing using the virtual relation can quickly extract a necessary record from the processing result of the composition relation calculation task. In this way, multi-operation processing using composite relational operations is performed by replacing several tasks collected in a subgroup with one composite relational calculation task, and each task in the subgroup is virtual Through the relation, the relation of the processing result of the composition related calculation task is partially shared. For this reason, it is not necessary to create relations of processing results including records with overlapping selection ranges and / or attribute columns between individual tasks in the subgroup, and the number of times the disk is accessed can be reduced. It is possible to reduce this, and it is possible to improve the query processing speed.

In addition, when a task performs a search process on a record of a virtual relation, an index is used for the attribute used to search for the relation obtained as a result of the processing of the synthetic relation calculation task that is partially shared by the virtual relation. Create. As a result, other tasks that perform a search process using a common attribute can also search for a record by sharing an index. Like a conventional join operation process using a hash method, There is no need to create a separate hash table in the main memory for the join operation task, and the query access speed can be improved by reducing the number of disk accesses.
In addition, tasks that perform processing on the processing results of the composite relation calculation task using virtual relations are not grouped based on virtual relations, but are combined relation calculations (including virtual relations). It is assumed that grouping is performed based on the relation obtained as a result of task processing, and these task processes are performed at once using multi-operation processing. By performing these task processing at once using multi-operation processing, the relation obtained as a result of the processing of the composition relation operation task will not be accessed many times and the query processing speed will be improved. Is possible.
By performing task processing from a query using the method described above, multi-operation processing using composition-related operations performs task processing more efficiently than task processing using only multi-operation processing. It is possible to increase the query processing speed by reducing the number of times the disk is accessed.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
First, an outline of multi-operation processing using the composition-related operation of the present invention will be described.

[1. Multi-operation processing using synthetic relational operations]
In multi-operation processing using synthetic relational operations, when a query queried by a user is converted to a processing tree composed of relational algebras by query optimization, tasks that are contact points on the processing tree are topologically processed. In the sort order, find a task that can be processed directly without dependency from other tasks. Then, these tasks are grouped based on the relation of the database accessed by each task, and the tasks in the group are collected into subgroups for each common subexpression, and for each subgroup, Create a composition-related operation task based on the tasks in the subgroup. Thereafter, multi-operation processing is used to process the tasks in the group including the composition related calculation task at a time.

[1-1. Database system architecture]
FIG. 1 shows an example of the architecture of a database system using the query processing method described in the text. The configuration shown here is basically the same as that shown in FIG. 1 of Japanese Patent Application No. 2006-356406 filed by the inventor described above.
In FIG. 1, the queries Q1 to Q6 are treated as queries inquired by the user, and the database architecture will be described. Query Q1~Q6 is optimized by the query optimizer (Query optimization) (900), it is converted to the processing tree P ₁ to P ₆ composed of a relational algebra (902). The query processor (901) controls a query optimizer (900) and a multi-operation processor (processor that performs multi-operation processing) (905).
A query processor (901) that performs a series of processing of queries has tasks t ₁ ¹ and t ₁ ³ that can be directly processed without dependency from other tasks in the order of topological sort from processing trees P _{1 to} P _6. , T ₁ ⁷ , t ₁ ⁹ , t ₂ ¹ , t ₂ ³ , t ₂ ⁴ , t ₃ ¹ , t ₃ ² , t ₄ ¹ , t ₄ ² , t ₅ ¹ , t ₅ ² , t ₆ ¹ , t Find ₆ ³ (903). Next, the query processor divides these tasks that can be directly processed into groups G1 to G4 based on the relation of the database accessed by each task. Tasks t ₁ ³ , t ₂ ¹ , t ₃ ² , t ₄ ¹ , t ₅ ¹ , t ₆ ³ are collected in group G1, and tasks t ₁ ¹ , t ₂ ³ , t ₃ ¹ , t ₆ ¹ are grouped in group G2 Then, tasks t ₁ ⁷ and t ₂ ⁴ are collected in group G3, and tasks t ₁ ⁹ , t ₄ ² and t ₅ ² are collected in group G4.

When collecting tasks into groups, the query processor further collects tasks with common subexpressions into subgroups. Tasks t ₁ ³ , t ₃ ² , and t ₆ ³ are collected in subgroup SG1 _G1 , tasks t ₄ ¹ and t ₅ ¹ are collected in subgroup SG2 _G1 , and tasks t ₂ ³ and t ₃ ¹ are collected in subgroup SG1 _G2 . Tasks t ₁ ⁷ and t ₂ ⁴ are collected in subgroup SG1 _G3 . When the query processor collects tasks in subgroups, it creates a composition relation operation task for the subgroups.
Create a composite relation calculation task t _G1 ^SG1 for subgroup SG1 _G1 , create a composite relation calculation task t _G1 ^SG2 for subgroup SG2 _G1 , and create a composite relation calculation task t _G2 ^SG1 for subgroup SG1 _G2 . And a composite relational calculation task t _G3 ^SG1 is created for the subgroup SG1 _G3 . When the composite relational calculation task is created, the query processor inserts the groups G1 to G4 into the group column (queue) (904).

  The multi-operation processor (905) that performs group processing takes out groups G1 to G4 from the group queue (queue) according to the number of available processes (four processes are prepared here as an example), and prepares them. Have each of the processes doing group processing using multi-operation processing. Here, it is assumed that process 1 performs group G1, process 2 performs group G2, process 3 performs group G3, and process 4 performs group G4. The processes of these processes are processed simultaneously by scheduling of the operating system (OS) process. If the database server includes a plurality of CPUs (907), group processing by each process is performed in parallel on different CPUs.

First, the process 1 performs the processing of the composition-related operation tasks t _G1 ^SG1 and t _G1 ^{SG2 in} the group _G1 and the task t ₂ ¹ not collected in the subgroup in the order of t ₂ ¹ , t _G1 ^SG1 , t _G1 ^SG2 . When finished, the query processor searches the processing tree (902) for tasks that can be newly processed. When task t ₂ ¹ is finished, task t ₂ ² can be newly started, and the query processor creates a new group G5 and adds task t ₂ ² to group G5. Insert G5 into the group column (queue) (904). Next, when the processing of task t _G1 ^SG1 is completed, tasks t ₁ ⁴ , t ₃ ³ , and t ₆ ⁴ can be newly processed, and the query processor newly creates group G6 and adds it to group G6. Tasks t ₁ ⁴ , t ₃ ³ , and t ₆ ⁴ are added to insert group G6 into the group column (queue) (904). Finally, when the processing of task t _G1 ^SG2 is completed, no new task can be found and no group is created. When the processing of group G1 ends, all processes other than process 1 are processing other groups, so that process 1 continues to extract group G5 from the group column and start processing of group G5. Become.
Each of the other processes 2 to 4 also takes out a group from the group column and performs processing in parallel.

In this way, as each process finishes processing the group, the group is sequentially taken out from the group column (904) to perform task processing in the group, and the multi-operation processor (905) As the group processing is repeated, the tasks in the processing tree (902) gradually approach the end, and when all the task processing in the processing tree is completed, all given query processing is completed. . When the query processor (901) is currently processing a query (query from Q1 to Q6) and there is a new query Q7 (909) from the user, the query the processor creates the process tree P ₇ with optimization for the new query Q7 using query optimizer, in the process tree P ₇ of topological sort order, the processing can be found tasks, in common with those tasks Check if there is a group in the group column that collects the tasks that access the relation. If such a group exists in an existing group, it will add a task to that group, and if it does not exist in the existing group, create a new group and add the task to that group. To. In addition, as the number of queries in the query increases, several groups wait in the group column while the process is processing the group, during which many tasks are gathered into the group, The collected tasks are further collected into subgroups so that many task processes can be performed at once. A database system that processes queries in this way efficiently performs many queries at high speed.

[1-2. Query processor flowchart using multi-operation processing using composition-related operations]
FIG. 2 is a flowchart for explaining a series of flows in which a query is processed using multi-operation processing using a composition relational operation.
First, using a relational database language such as SQL, a query query is input from the user to the database server (S110). The syntax of the queried SQL is converted into a processing tree composed of relational operations by query optimization processing by the query optimizer (900) (S120). The query processor (901) finds tasks that can be directly processed in the order of topological sort (S130). When a task that can be directly processed is found, it is checked whether there is a group in the group column in which the relations accessed by these tasks and the tasks accessing the common relations are collected (S140). If a group in which tasks that access the common relation are collected exists in the group column, the task is added to the group (S150). If it does not exist, a new group is created for the task, a task is added to the group, and the group is inserted into the group column (S160).
The processing so far is the same as that described in Japanese Patent Application No. 2006-356406 by the inventor described above.

When the tasks are collected in the group, the tasks having the common subexpression among the tasks in the group are further collected in a subgroup (S170). When the tasks are collected in the subgroup, a composite relation calculation task is created for the subgroups in the group based on the tasks in the subgroup (S180).
The multi-operation processor (905) extracts groups from the group column as many as the number of processes that can be used, and uses multi-operation processing to process composite related arithmetic tasks within the group and tasks that do not gather into subgroups at once. Perform (S190). When the processing of the synthetic relational calculation task in the group is completed, a virtual relation is created for the task in the subgroup so that the records in the processing result of the synthetic relational calculation task can be partially shared (S200).

When task processing in the group ends, it is checked whether all task processing in the processing tree has ended (S210). If there are still tasks remaining in the processing tree, the next process can be repeatedly found from the processing tree.
When all the task processes in the processing tree are completed, the query processing corresponding to the processing tree is completed.

[1-3. Multi-operation processing algorithm using composite relational operations]
When processing tasks collected in a group using multi-operation processing using synthetic relational operations at once, the multi-operation processing algorithm using synthetic relational operations is divided into steps 1 to 3, Further explanation will be given.

[(A) Step 1: Task sub-grouping]
When processing the tasks in the group for the common relation R, the definition of the common subexpression between tasks is defined as follows, and the tasks in the group are collected into subgroups for each common subexpression (S170). .
-Definitions related to common subexpressions:
The task t _i and the task t _j have a common subexpression if the following conditions regarding the selection operation, projection operation, and other operations are satisfied.
・ Selection calculation:
Task t _i is a selection operation task used for selection conditions (connected by AND and OR) for attributes R ₁ , A ₂ , A ₃ ,..., A _k for relation R, and task t _j is same relation R same attributes for _{a 1, a 2, a 3} , ..., when a select operation task used selection for a _k conditions (aND, those bonded with OR), and a task t _i In the selection conditions used by task t _j , only the selection conditions for one attribute A _i (1 ≦ i ≦ k) are different or the same conditions, and the selection conditions for attributes other than A _i are exactly the same conditions. is there.
Projection calculation:
The task t _i is a projection operation task for the relation R, and the task t _j is a projection operation task for the same relation R.
・ Other relational operations:
t _i and t _j are tasks of the same relational operation (t _i ≡t _j ).
The calculations used for the conditions defined above relate only to common subexpressions.

[(B) Step 2: Creation of composition-related operation task]
When the tasks in the group are grouped into subgroups by common subexpression in step 1, depending on the type of operation of the tasks in the subgroup, for each subgroup in the group using the following method: A composition relation calculation task is created (S180).

-How to create a composite selection calculation task:
Selection calculation task TEMP_T1 ← σ _{<selection condition 1>} R, TEMP_T2 ← σ _{<selection condition 2>} R, TEMP_T3 ← σ _{<selection condition 3>} R,…, TEMP_Tn ← σ _{<selection condition n>} R In order to connect the selected condition <selection condition i> (i = 1,2, ..., n) using OR of Boolean operations, and remove the overlapping part of the selection range from the connected selection condition, One synthesis selection calculation task is created by performing the following optimization.
TEMP_SG ← σ _{optimize (<selection condition 1> OR <selection condition 2> OR <selection condition 3> … OR <selection condition n>)} R
Here, σ _{<selection condition i>} R (i = 1, 2,..., N) means that a selection operation is performed on relation R based on the selection condition <selection condition i>, and σ _{optimize (... )} Means performing a selection operation by optimization. TEMP_Ti ← σ _{<selection condition i>} R represents a task to be selected (σ) in accordance with the selection condition <selection condition i> for relation R, and the processing result is recorded in TEMP_Ti.

-How to create a composite projection calculation task:
Projection task in subgroup TEMP_T1 ← π _{<attribute list 1>} R, TEMP_T2 ← π _{<attribute list 2>} R, TEMP_T3 ← π _{<attribute list 3>} Used for R,…, TEMP_Tn ← π _{<attribute list n>} R The attribute list <attribute list i> (i = 1, 2,..., N) is converted into a set Si, and the attributes from each task are converted into a set TS = S1∪ using a union. S2∪S3∪… collect in Sn. Then, the attribute set TS is converted into an attribute list <attribute list SG>, and a composite projection operation task TEMP_SG ← π _{<attribute list SG>} R is created. Here, π _{<attribute list i>} R (i = 1, 2,..., N) means that a projection operation is performed on the relation R based on the attribute list <attribute list i>. Also, TEMP_Ti ← π _{<attribute list i>} R (i = 1,2, ..., n) records that the result of projection operation on relation R based on attribute <attribute list i> is recorded in TEMP_Ti. It shall represent.

・ Other methods for creating composition-related computation tasks:
Since tasks of the same relational operation are collected in the subgroup, one of the tasks in the subgroup is assumed to be used as a composite relational calculation task.

[(C) Step 3: Group processing using multi-operation processing]
The multi-operation processing is performed on the composite relation calculation task created for each subgroup in the group using step 2 and the tasks not collected in the subgroup in the group (S190).
As this multi-operation processing, two processing methods of dynamic multi-operation processing and static multi-operation processing have been proposed (see Japanese Patent Application No. 2006-356406). In this embodiment, static multi-operation processing is performed. We will use it as multi-operation processing. When processing is performed using static multi-operation processing, an access plan is created for the composition-related computation tasks in the group and tasks that do not gather in subgroups in the group, and the processing cost of each task is calculated from the access plan. In order to process in order from the task with the lowest processing cost to the task with the higher processing cost, the order of the blocks in the relation to be accessed is determined, the blocks in the disk are accessed according to the order, and this block is shared. As a block, task processing in a group that needs to be processed on this block is processed at a time.

  According to this method, processing of each task included in a query is extremely logically performed using set theory such as a union set, a product set, and a difference set in accordance with the order of blocks to be accessed (common blocks).

[(D) Virtual relation]
Since the processing results of the composite relational operation task processed by multi-operation processing using the composite relational operation include all of the processing results of the individual tasks in the subgroup, the tasks in the subgroup are combined. The processing result of the relational calculation task is partially shared.
Create a virtual relation for each task in a subgroup and share the result of the synthetic relational calculation task in the virtual relation to show that the result of the synthetic relational calculation task is partially shared Record the information necessary for this.
If the composition relation calculation task is a selection calculation, create a relation of the processing results arranged by the attribute used in the selection condition, and as a virtual relation, the relation name of the processing result of the combination relation calculation to be shared, the storage location of the record ( Information such as the record row range and the block number and address in which the record is stored is recorded.
Further, when the compositing-related calculation task is a projection calculation, information such as a relation name of a processing result to be shared and an attribute storage position (column number) is recorded as a virtual relation.
By recording these pieces of information in the virtual relation, a task that performs processing using the virtual relation can quickly extract the necessary record from the processing result of the synthetic relation calculation task (S200). .

In this way, a number of tasks collected in a subgroup are replaced with a single composite relational calculation task, and each task in the subgroup partially processes the processing results of the composite relational calculation task through a virtual relation. Since there is no need to separately create relations on the disk that include records with overlapping selection ranges and attributes (columns) among individual tasks in the subgroup, The number of accesses can be reduced, and the query processing speed can be improved.
In addition, tasks that are processed using virtual relations are not grouped based on virtual relations, but have relations obtained as a result of processing of synthetic relational calculation tasks (including virtual relations). Suppose that these tasks are processed at once using multi-operation processing. By performing these task processing at once using multi-operation processing, the relation block obtained as a result of the processing of the composition relation operation task is not accessed many times, and the query processing speed is improved. It becomes possible to make it.

  As described above, by performing query processing using multi-operation processing using composition-related operations, more task processing can be performed at once than query processing using only multi-operation processing. Thus, the number of times the disk is accessed can be reduced, and the query processing speed can be improved.

[2. Specific examples of multi-operation processing using composition-related operations]
Here, the multi-operation processing using the composite relational operation described above will be described using examples of queries Q _{1 to} Q ₅ for the database having the data structure shown in FIGS. 3-1 to 3-3. .

[2-1. Relation and query processing
[(A) Relation example]
FIGS. 3A to 3C show a database composed of relations DEPARTMENT, EMPLOYEE, WORKS_ON, and PROJECT.
The relation DEPARTMENT (see FIG. 3-1 (a)) stores 25 records in 5 blocks, and each block has 5 records, and each block has the next block. Has a block pointer. The main attribute DNUMBER of the relation DEPARTMENT has a main index (100), and the main index has an index pointer for each block. The attribute DPHONE of the relation DEPARTMENT has a secondary index (102), and the secondary index has an index pointer for each record in the relation DEPARTMENT.
In relation EMPLOYEE (see Fig. 3-2), 20 records are stored in 5 blocks, and there are 4 records in each block. Each block is a block for the next block. Have a pointer. The main attribute SSN of the relation EMPLOYEE has a main index (104), and the main index has an index pointer for each block.

In the relation PROJECT (see Fig. 3-3 (c)), 10 records are stored in 2 blocks, and 5 records exist in each block. Has a block pointer. The main attribute PNUMBER of the relation PROJECT has a main index (106), and the main index has an index pointer for each block.
In the relation WORKS_ON (see FIG. 3-3 (d)), 25 records are stored in five blocks, and there are five records in each block. Each block has a block pointer to the next block. The main attributes ESSN and PNO of the relation WORKS_ON are foreign keys to the relations EMPLOYEE and PROJECT. The following table summarizes the above.

[(B) Query example]
Next, in order to explain multi-operation processing using composition-related operations based on the databases shown in FIGS. 3-1 to 3-3, queries Q ₁ , Q ₂ , Q as shown below are used. _3, Q _4, Q _5, to be taken up to Q ₆ process. Assume that the following six queries Q ₁ , Q ₂ , Q ₃ , Q ₄ , Q ₅ , and Q ₆ have been made to the database shown in FIGS.

(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';

[2-2. Create processing plan]
The query processor optimizes the query for each query Q ₁ , Q ₂ , Q ₃ , Q ₄ , Q ₅ , Q ₆ that has been queried and is the best way to process each query. The following processing plan, which is the processing method, will be created. It creates process plans P ₁ for the query Q _1, creates process plans P ₂ for the query Q _2, creates process plans P ₃ for the query Q _3, the processing plan for the query Q ₄ create a P _4, creates process plans P ₅ for the query Q _5, to create a process plan P ₆ for the query Q _6.

When the created processing plan is represented by a processing tree, it becomes P _{1 to} P ₆ as shown in FIGS.
Tasks t _i ^j in processing tree P _i (where i represents the number of the processing tree and j represents the processing number in each processing tree) are as follows:
(T _i ^j ): processing result ← represented as relational algebra, and processing result represents the result of processing the relational algebra. If the processing result name is TEMP_Tj_i, the processing result of the task t _i ^j in the process tree P _i represents the (intermediate result of the processing tree), if the processing result is RESULT_Q _i, is the processing result of the processing tree P _i Represents that. Relational algebra is an operation that directly performs processing on database relations, such as a selection operation (σ), a projection operation (π), and a join operation (| X |).

Processing plan 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 = DNUM} TEMP_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, PNO} WORKS_ON
(t ₁ ¹⁰ ): TEMP_T10_1 ← TEMP_T8_1 | X | _{PNUMBER = PNO} TEMP_T9_1
(t ₁ ¹¹ ) ： TEMP_T11_1 ← π _{ESSN, PNUMBER, PNAME} TEMP_T10_1
(t ₁ ¹² ): TEMP_T12_1 ← TEMP_T6_1 | X | _{SSN = ESSN} TEMP_T11_1
(t ₁ ¹³ ): RESULT_Q1 ← π _{LNAME, DNUMBER, DNAME, PNUMBER, PNAME} TEMP_T12_1

Processing plan 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 = DNUM} TEMP_T5_2
(t ₂ ⁷ ): TEMP_T7_2 ← π _{DNUMBER, DNAME, MGRSSN, PNUMBER, PNAME} TEMP_T6_2
(t ₂ ⁸ ) ： TEMP_T8_2 ← TEMP_T2_2 | X | _{SSN = MGRSSN} TEMP_T7_2
(t ₂ ⁹ ): RESULT_Q2 ← π _{DNAME, DNUMBER, PNAME, PNUMBER, SSN, LNAME, BDATE} TEMP_T8_2

Processing plan 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 = DNUM} TEMP_T3_3
(t ₃ ⁵ ): RESULT_Q3 ← π _{SSN, FNAME, LNAME, DNAME, DNUMBER} TEMP_T4_3

Processing plan P ₄
(t ₄ ¹ ): TEMP_T1_4 ← DEPARTMENT | X | _{DNUMBER = DNUM} EMPLOYEE
(t ₄ ² ): TEMP_T2_4 ← PROJECT | X | _{PNUMBER = PNO} WORKS_ON
(t ₄ ³ ): RESULT_Q4 ← TEMP_T1_4 | X | _{SSN = ESSN} TEMP_T2_4

Processing plan P ₅
(t ₅ ¹ ): TEMP_T1_5 ← DEPARTMENT | X | _{DNUMBER = DNUM} EMPLOYEE
(t ₅ ² ): TEMP_T2_5 ← σ _{HOURS <10} WORKS_ON
(t ₅ ³ ): RESULT_Q5 ← TEMP_T1_5 | X | _{SSN = ESSN} TEMP_T2_5

Treatment plan P ₆
(t ₆ ¹ ): TEMP_T1_6 ← σ _{DNUMBER = 7} DEPARTMENT
(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 = DNUM} TEMP_T4_6
(t ₆ ⁶ ): RESULT_Q6 ← π _{FNAME, LNAME, DNUMBER, DNAME} TEMP_T5_6

[2-3. Task grouping and subgrouping]
[(A) Task grouping]
Created based on the processing plans P ₁ , P ₂ , P ₃ , P ₄ , P ₅ , and P ₆ shown in FIGS. Tasks t ₁ ¹ , t ₁ ³ , t ₁ ⁷ , t ₁ ⁹ , t ₂ ¹ , t ₂ ³ , t _{2 that} can be processed directly without dependency from other tasks in the order of topological sort from the processed tree ⁴ , t ₃ ¹ , t ₃ ² , t ₄ ¹ , t ₄ ² , t ₅ ¹ , t ₅ ² , t ₆ ¹ , t ₆ ³ are found and grouped based on the relation of the database accessed by each task If you divide into the following, it will be grouped as follows.

In addition, in the case of a join operation task that accesses two relations, grouping is performed based on the relation of the search source, not the relation of the search destination.
EMPLOYEE: Group G1 = {t ₁ ³ , t ₂ ¹ , t ₃ ² , t ₄ ¹ , t ₅ ¹ , t ₆ ³ }
DEPARTMENT: Group G2 = {t ₁ ¹ , t ₂ ³ , t ₃ ¹ , t ₆ ¹ }
PROJECT: Group G3 = {t ₁ ⁷ , t ₂ ⁴ }
WORKS_ON: Group G4 = {t ₁ ⁹ , t ₄ ² , t ₅ ² }

  Tasks that access the relation EMPLOYEE are collected in the group G1, tasks that access the relation DEPARTMENT are collected in the group G2, and tasks that access the relation PROJECT are collected in the group G3. In the group G4, tasks that access the relation WORKS_ON are collected and grouped.

[(B) Task sub-grouping]
When tasks are divided into groups G1, G2, G3, and G4, tasks having a common subexpression among the tasks in the group are further divided into subgroups SG1 _G1 , SG2 _G1 , SG1 _G2 for each common subexpression as follows: , SG1 _G3 .

EMPLOYEE: Group G1 = {SG1 _G1 , SG2 _G1 , t ₂ ¹ }
Subgroup SG1 _G1 = {t ₁ ³ , t ₃ ² , t ₆ ³ }
Subgroup SG2 _G1 = {t ₄ ¹ , t ₅ ¹ }
DEPARTMENT: Group G2 = {SG1 _G2 , t ₁ ¹ , t ₆ ¹ }
Subgroup SG1 _G2 = {t ₂ ³ , t ₃ ¹ }
PROJECT: Group G3 = {SG1 _G3 }
Subgroup SG1 _G3 = {t ₁ ⁷ , t ₂ ⁴ }
WORKS_ON: Group G4 = {t ₁ ⁹ , t ₄ ² , t ₅ ² }

The subgroup SG1 _G1 is a subgroup in which selection calculation tasks using the attribute BDATE described in the definition of the common subexpression for the relation EMPLOYEE as a selection condition are collected.
The subgroup SG2 _G1 is a subgroup in which tasks for performing the same relational operation processing described in the definition of the common subexpression for the relation EMPLOYEE are collected.
The subgroup SG1 _G2 is a subgroup of tasks for performing the projection operation processing described in the definition of the common subexpression for the relation DEPARTMENT.
The subgroup SG1 _G3 is a subgroup in which the selection operation tasks that use the attributes PNAME and PLOCATION described in the definition of the common subexpression for the relation PROJECT as a selection condition are collected, and in the selection conditions used by these tasks, The selection conditions for the attribute PNAME are different, but the selection conditions for the other attributes PLOCATION are exactly the same.
Since tasks t ₁ ⁹ , t ₄ ² , and t ₅ ² in group G4 do not have a common subexpression, no subgroup is created in group G4.

FIG. 5 shows tasks t ₁ ¹ , t ₁ ³ , t ₁ ⁷ , t ₁ ⁹ , t ₂ ¹ , t ₂ ³ , t ₂ ⁴ , t ₃ ¹ , which can be processed directly from the processing tree in the order of topological sort. t ₃ ² , t ₄ ¹ , t ₄ ² , t ₅ ¹ , t ₅ ² , t ₆ ¹ , t ₆ ³ (300) are grouped into groups G 1, G 2, This shows that the tasks having a common subexpression among the tasks in the group are divided into subgroups SG1 _G1 , SG2 _G1 , SG1 _G2 , SG1 _G3 for each common subexpression.

[(C) Creation of composition-related operation task]
If subgroups in the group is created, the subgroup _{SG1 G1, SG2 G1, SG1 G2} , SG1 G3 synthesized as follows with respect to relational operations task ^{_{t G1 SG1, t G1 SG2,}} t G2 SG1 created, t _G3 ^SG1 can be created.
(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 = DNUM} EMPLOYEE
(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

The synthesis-related calculation task obtained as described above will be described as follows.
The task t _G1 ^SG1 connects the selection conditions of the selection calculation tasks t ₁ ³ , t ₃ ² , and t ₆ ³ in the subgroup SG1 _G1 using a Boolean OR, as shown below, and selects one selection condition < Create a temp_cond>, create a selection condition that has been optimized and optimized (<temp_cond>) in order to remove the overlapping part of the selection range from the connected selection conditions, and in the synthesis selection operation task using that selection condition is there.
<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>'1-JAN-1972'
The selection condition represented by Optimize (<temp_cond>) is obtained by calculating the logical sum (Union) of the selection range of each selection condition in order to optimize the selection condition <temp_cond> created using OR of Boolean operations. This is obtained as a newly simplified selection condition by removing the overlapping portion of the selection range.

This optimization will be described in detail with reference to FIG. 6 using the above-described task t _G1 ^SG1 .
6 (a) is selected conditional BDATE <'DEC-31-1961' a is date of birth of the selection of the task t ₁ ³ connecting with the OR Boolean operations, selection of the task t ₆ ³ Selection date of birth with condition BDATE>'FEB-11-1959' AND BDATE <'NOV-21-1966', selection condition for task t ₃ ² BDATE> date of birth of 'JAN-1-1971' The selection range is represented on one horizontal line from left to right in order from the smallest date of birth.
Next, as shown in FIG. 6 (b), when the logical sum (Union) of the date of birth selection range used for the selection conditions of tasks t ₁ ³ , t ₃ ² , and t ₆ ³ is obtained, BDATE It can be seen that only the selection range of BDATE after NOV-21-1966 and BDATE value JAN-1-1971 is necessary.
In this way, when the selection range of the date of birth obtained by the logical sum of the selection ranges of the selection conditions is changed to a new selection condition, “BDATE <'NOV-21-1966' OR BDATE>'JAN-1-1971'” As described above, this selection condition is used as the selection condition for the selection calculation of the composite selection calculation task t _G1 ^SG1 .

Task t _G1 ^SG2 is because the task is the same join operation in the subgroup ^{_{SG2 G1 (t 4 1 ≡t 5}} 1), using one of the join operation tasks in the subgroup SG2 _G1 as it is synthetic relational operation tasks It will be.
The task t _G2 ^SG1 is a composite projection calculation task created by using the union for the attributes used in the projection calculation tasks t ₂ ³ and t ₃ ¹ in the subgroup SG1 _G2 .
Task t _G3 ^SG1 may create <temp_cond> 1 one selection condition connected with the OR Boolean selection operation tasks t ₁ ^7, t ₂ ⁴ selection conditions subgroup SG1 in _G3 as shown below This is a composite selection calculation task created by performing optimization Optimize (<temp_cond>) in order to remove the overlapping part of the selection range from the connected selection conditions.
<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>) calculates the logical sum (Union) of the selection ranges of each selection condition in order to optimize the selection condition <temp_cond> created using Boolean OR. This was obtained as a newly simplified selection condition by removing the part PLOCATION = 'New York'.

As described above, when a composite relational calculation task is created for a subgroup in a group, the subgroup in the group can be replaced with the composite relational calculation task as follows.
EMPLOYEE: Group ^{_{G1 = {t G1 SG1, t}} G1 SG2, t 2 1}
DEPARTMENT: Group ^{_{G2 = {t G2 SG1, t}} 1 1, t 6 1}
PROJECT: Group G3 = {t _G3 ^SG1 }
WORKS_ON: Group G4 = {t ₁ ⁹ , t ₄ ² , t ₅ ² }

[2-4. Computation-related calculation task processing by multi-operation processing]
When a subgroup in a group is replaced with a composition-related operation task, multi-operation processing is applied to process the tasks in the group including the composition-related operation task in the group at once. A case will be described in which static multi-operation processing (see Japanese Patent Application No. 2006-356406) is used as multi-operation processing to perform processing of groups G1, G2, G3, and G4.

[(A) Group G1 processing]
It will be the processing of the task t ₂ ¹ not gather the synthetic select operation task t _G1 ^SG1, t _G1 ^SG2 and subgroups in the group G1 using static multi-operation processing at a time. As described above, each task in the group G1 is as follows.
EMPLOYEE: Group ^{_{G1 = {t G1 SG1, t}} G1 SG2, t 2 1}
(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 = DNUM} EMPLOYEE
(t ₂ ¹ ): TEMP_T1_2 ← σ _{SSN = 164545566} EMPLOYEE

[(A-1) Access plan for each task]
First the task _{^{t G1 SG1, t G1 SG2,}} t 2 1 in the group G1 to create the following access plan.
plan (t _G1 ^SG1 ): Selects EMPLOYEE by linear search.
plan (t _G1 ^SG2 ): Scans EMPLOYEE and performs join processing using DEPARTMENT's primary index.
plan (t ₂ ¹ ): Selects using the main index of EMPLOYEE.

[(A-2) Processing cost of each task]
After creating an access plan for each task, the processing cost of each task is calculated based on the access plan as follows.
Task t _G1 ^SG1 processing cost: cost (t _G1 ^SG1 ) = b = 5
Task t _G1 ^SG2 processing cost: cost (t _G1 ^SG2 ) = b _E + (| EMPLOYEE | * (x _D +1)) = 5+ (20 * (1 + 1)) = 45
Task t ₂ ¹ processing cost: cost (t ₂ ¹ ) = x _E + 1 = 2
The processing cost is the number of times the disk is accessed for task processing. Here, the purpose is to reduce the number of times the disk is accessed in order to perform the task processing. Therefore, the time for calculation in the main memory and the cost for storing the processing result in the disk are omitted. Further, cost () represents the processing cost.

The processing cost of task t _G1 ^SG1 is linear search for the relation EMPLOYEE and accesses five blocks, so the processing cost is b _E = 5.
The processing cost of task t _G1 ^{SG2 is} the processing cost of scanning relation EMPLOYEE b _E and the processing cost of finding records that can be combined using the primary index of relation DEPARTMENT for each record in EMPLOYEE | EMPLOYEE | * (x _D +1) is the total processing cost.
In relation EMPLOYEE, 20 records are stored in 5 blocks. x _D +1 is the processing cost for accessing the level and block of a multi-level index such as a B ⁺ tree index, and the level x _D of the main index existing in the relation DEPARTMENT in FIG. The processing cost of t _G1 ^SG2 is b _E + (| EMPLOYEE | * (x _D +1)) = 5+ (20 * (1 + 1)) = 45.
The processing cost of task t ₂ ^{1 is} the processing cost for searching for one record using the main index. This is the processing cost to access the block EMPLOYEE main index level x _E of the relation, and the processing index is x _E + 1 = 2 since the level of the main index of the relation EMPLOYEE in FIG. 3-2 is 1. It is.

To the task _{^{t G1 SG1, t G1 SG2,}} t 2 1 As described above, the processing cost is calculated, based on the processing cost, Rearranging these tasks from increasing order of processing cost as follows Become.
sort (t _G1 ^SG1 , t _G1 ^SG2 , t ₂ ¹ ) ⇒ (t ₂ ¹ , t _G1 ^SG1 , t _G1 ^SG2 )
sort (...) represents sorting.

[(A-3) Set of blocks corresponding to each task]
When processing the tasks t ₂ ¹ , t _G1 ^SG1 , t _G1 ^SG2 , all the blocks of the relation that need to be accessed using the index are examined in advance, and the block sets B ₂ ¹ , B _G1 corresponding to each task ^SG1, B _G1 by collecting the ^SG2, as follows.
Block set for task t ₂ ¹ : B ₂ ¹ = {b ₂ }
Block set for task t _G1 ^SG1 : B _G1 ^SG1 = {b ₁ , b ₂ , b ₃ , b ₄ , b ₅ }
Block set for task t _G1 ^SG2 : B _G1 ^SG2 = {b ₁ , b ₂ , b ₃ , b ₄ , b ₅ }
Thus, the block sets B ₂ ¹ , B _G1 ^SG1 , and B _G1 ^SG2 corresponding to the tasks t ₂ ¹ , t _G1 ^SG1 , and t _G1 ^SG2 can be found because of the following reasons. It is.

The task t ₂ ¹ needs a record that satisfies the selection condition “SSN = 164545566”. Using the primary index of the relation EMPLOYEE, you can see that the record with attribute SSN value 164545566 is stored in block b ₂ with a relative block address of 256, and only block b ₂ needs to be accessed. Therefore, the set of blocks that need to be accessed to perform the task t ₂ ¹ is {b ₂ }. When the first block address of the relation EMPLOYEE zero the relative address of the block b _2, in which the block b ₂ is expressed or are stored in was many bytes moved from there.

The task t _G1 ^SG1 needs a record that satisfies the selection condition “BDATE <'NOV-21-1966' OR BDATE>'JAN-1-1971'". Since there is no index on attribute BDATE of relation EMPLOYEE, it is necessary to access blocks from the first block b ₁ to the last block b _{5 of} relation EMPLOYEE to linearly search all records in relation EMPLOYEE Therefore, the set of blocks that need to be accessed in order to perform the task t _G1 ^SG1 is {b ₁ , b ₂ , b ₃ , b ₄ , b ₅ }.

Since task t _G1 ^SG2 needs to access the blocks from the first block b ₁ to the last block b ₅ of the relation EMPLOYEE in order to perform the join operation, it processes task t _G1 ^SG2. Therefore, the set of blocks that need to be accessed is {b ₁ , b ₂ , b ₃ , b ₄ , b ₅ }.

[(A-4) Determination of order of blocks to be accessed (common blocks)]
As described above, after finding a block set corresponding to each task, each task is in order from a task with a low processing cost to a task with a high processing cost, that is, in order of tasks t ₂ ¹ , t _G1 ^SG1 , t _G1 ^SG2. Let's find the union of the block set corresponding to the task.
First, as TB ₀ = {} (empty set), a block set B ₂ ¹ and a union set TB ₂ ¹ corresponding to TB ₀ and task t ₂ ¹ are obtained. Then, the sum set TB _G1 ^SG1 of the block set B _G1 ^SG1 corresponding to the TB ₂ ¹ and task t _G1 ^SG1. Furthermore, the sum set TB _G1 ^SG2 of the block set B _G1 ^SG2 corresponding to the TB _G1 ^SG1 and the task t _G1 ^SG2 is obtained as follows. In this case, when obtaining the union, the newly added set is added last in the union.
TB ₀ = {}
Union set with set B ₂ ¹ corresponding to task t ₂ ¹ : TB ₂ ¹ = TB ₀ ∪B ₂ ¹ = {b ₂ }
The union of the set B _G1 ^SG1 corresponding to the task t _G1 ^SG1 : TB _G1 ^SG1 = TB ₂ ¹ ∪B _G1 ^SG1 = {b ₂ , b ₁ , b ₃ , b ₄ , b ₅ }
Union of a set B _G1 ^SG2 corresponding to the task ^{_{t G1 SG2: TB G1 SG2 =}} TB G1 SG1 ∪B G1 SG2 = {b 2, b 1, b 3, b 4, b 5}

As described above, when the union is obtained in order from the block set corresponding to the task with the low processing cost to the block set corresponding to the task with the high processing cost, the last task (the task with the highest processing cost) From the union TB _G1 ^SG2 with the block set corresponding to, access should be started from block b _{2 of} the disk, and access should be terminated at block b ₅ , and access to the blocks in the relation EMPLOYEE on the disk The order can be determined as (b ₂ , b ₁ , b ₃ , b ₄ , b ₅ ). The reason for obtaining the union by this method is to determine the order in which blocks in the disk should be accessed in order from the task with the lowest processing cost. Since the blocks b ₂ , b ₁ , b ₃ , b ₄ , and b ₅ obtained in this way can be shared when processing the tasks t ₂ ¹ , t _G1 ^SG1 , t _G1 ^SG2 in order, These blocks are called common blocks.

Looking at the blocks contained in the block sets B ₂ ¹ , B _G1 ^SG1 and B _G1 ^SG2 described above, the block b ₂ is used to process the tasks t ₂ ¹ , t _G1 ^SG1 and t _G1 ^SG2. Block b ₁ is used to process tasks t _G1 ^SG1 and t _G1 ^SG2 , and blocks b ₃ , b ₄ and b ₅ are used to process tasks t _G1 ^SG1 and t _G1 ^SG2 I understand that. If these blocks are handled as common blocks, tasks that require these common blocks can be processed at once on the common block. The following table summarizes the above.

[(A-5) Task processing in common block]
As described above, in order to find out what kind of task is processed in each common block, the block sets B ₂ ¹ , B created for the tasks t ₂ ¹ , t _G1 ^SG1 , t _G1 ^SG2 Based on the information of _G1 ^SG1 and B _G1 ^SG2, the following procedure may be used.
First, the block b ₂ whose block relative address is 256 is accessed from the disk, the data in the block b ₂ is read into the main memory, and the tasks t ₂ ¹ , t _G1 ^SG1 and t _G1 ^SG2 in the group block to investigate whether it is necessary to perform processing in b _2, between the block b ₂ a expressed as a set {b _2}, the {b _2} a set of blocks ^{_{B 2 1, B G1 SG1,}} B G1 SG2 Then, the product set (Intersection) is obtained as follows.
For task t ₂ ¹ : B ₂ ¹ ∩ {b ₂ } = {b ₂ }
For task t _G1 ^SG1 : B _G1 ^SG1 ∩ {b ₂ } = {b ₂ }
For task t _G1 ^SG2 : B _G1 ^SG2 ∩ {b ₂ } = {b ₂ }

The product set for tasks t ₂ ¹ , t _G1 ^SG1 , t _G1 ^SG2 is {b ₂ }, and task t ₂ ¹ , t _G1 ^SG1 , t _G1 ^SG2 must perform processing in block b ₂ read into the main memory As a result, the block b ₂ becomes a common block, and each task is processed in the common block b ₂ . When the processing of the task in the block b ₂ which is the common block is completed, it is not necessary to access the block b ₂ again, so that the set B ₂ ¹ , B _G1 ^SG1 and B _G1 ^SG2 are set to remove the block b _2. Find the difference (Difference) with {b ₂ }. If the values of the obtained difference set are B ₂ ^{1 (1)} , B _G1 ^{SG1 (1)} , and B _G1 ^{SG2 (1)} , the result is as follows.
For task t ₂ ¹ : B ₂ ¹ − {b ₂ } = {} = B ₂ ^{1 (1)}
For task t _G1 ^SG1 : B _G1 ^SG1 − {b ₂ } = {b ₁ , b ₃ , b ₄ , b ₅ } = B _G1 ^{SG1 (1)}
For task t _G1 ^SG2 : B _G1 ^SG2 − {b ₂ } = {b ₁ , b ₃ , b ₄ , b ₅ } = B _G1 ^{SG2 (1)}
As a result, it can be seen that the set B ₂ ^{1 (1)} becomes the empty set {} and the processing of the task t ₂ ¹ is completed.

Next, block b ₁ whose block relative address is 0 is accessed from the disk, the data in block b ₁ is read into the main memory, and task t _G1 in the group excluding task t ₂ ¹ that has already been processed ^SG1, in order t _G1 ^SG2 determine whether it is necessary to perform processing in blocks b _1, represents a block b ₁ as a set {b _1}, {b _1} and the set of blocks B _G1 ^{SG1 (1),} The product set with B _G1 ^{SG2 (1)} is calculated as follows.
For task t _G1 ^SG1 : B _G1 ^{SG1 (1)} ∩ {b ₁ } = {b ₁ }
For task t _G1 ^SG2 : B _G1 ^{SG2 (1)} ∩ {b ₁ } = {b ₁ }
The product set for tasks t _G1 ^SG1 and t _G1 ^SG2 is {b ₁ }, and tasks t _G1 ^SG1 and t _G1 ^SG2 need to perform processing in block b ₁ read into the main memory, and block b ₁ is a common block Thus, each task is processed in the common block b ₁ . When the processing of the task in the block b ₁ which is a common block is completed, it is not necessary to access the block b ₁ again, so that the set B _G1 ^{SG1 (1)} , B _G1 ^{SG2 (1)} and the set {b ₁ } Find the difference set. ^Assuming that the values of the difference set are B _G1 ^{SG1 (2)} and B _G1 ^{SG2 (2)} , the following is obtained.
For task t _G1 ^SG1 : B _G1 ^{SG1 (1)} − {b ₁ } = {b ₃ , b ₄ , b ₅ } = B _G1 ^{SG1 (2)}
For task t _G1 ^SG2 : B _G1 ^{SG2 (1)} − {b ₁ } = {b ₃ , b ₄ , b ₅ } = B _G1 ^{SG2 (2)}

Next, the block b ₃ whose block relative address is 512 is accessed from the disk, the data in the block b ₃ is read into the main memory, and the task t _G1 in the group excluding the already processed task t ₂ ^{1 SG1,} t _G1 ^SG2 is to determine whether it is necessary to perform processing at block b _3, represents the block b ₃ as a set _{{b 3}, {b 3} } a set of blocks B _G1 ^{SG1 (2),} The product set with B _G1 ^{SG2 (2)} is as follows.
For task t _G1 ^SG1 : B _G1 ^{SG1 (2)} ∩ {b ₃ } = {b ₃ }
For task t _G1 ^SG2 : B _G1 ^{SG2 (2)} ∩ {b ₃ } = {b ₃ }
The product set for tasks t _G1 ^SG1 and t _G1 ^SG2 is {b ₃ }, and tasks t _G1 ^SG1 and t _G1 ^SG2 must perform processing in block b ₃ read into the main memory, and block b ₃ is a common block Thus, the tasks t _G1 ^SG1 and t _G1 ^SG2 are processed in the common block b ₃ . When the processing of the task in the block b ₃ which is a common block is completed, it is not necessary to access the block b ₃ again, so the set B _G1 ^{SG1 (2)} , B _G1 ^{SG2 (2)} and the set {b ₃ } When the difference set is obtained and the values of the obtained difference set are B _G1 ^{SG1 (3)} and B _G1 ^{SG2 (3)} , the following is obtained.
For task t _G1 ^SG1 : B _G1 ^{SG1 (2)} − {b ₃ } = {b ₄ , b ₅ } = B _G1 ^{SG1 (3)}
For task t _G1 ^SG2 : B _G1 ^{SG2 (2)} − {b ₃ } = {b ₄ , b ₅ } = B _G1 ^{SG2 (3)}

Next, block b ₄ whose block relative address is 768 is accessed from the disk, the data in block b ₄ is read into the main memory, and task t _G1 in the group excluding already processed task t ₂ ^{1 SG1,} in order t _G1 ^SG2 determine whether it is necessary to perform processing at block b _4, represents a block b ₄ as a set _{{b 4}, {b 4} } a set of blocks B _G1 ^{SG1 (3),} The product set with B _G1 ^{SG2 (3)} is as follows.
For task t _G1 ^SG1 : B _G1 ^{SG1 (3)} ∩ {b ₄ } = {b ₄ }
For task t _G1 ^SG2 : B _G1 ^{SG2 (3)} ∩ {b ₄ } = {b ₄ }
The product set for tasks t _G1 ^SG1 and t _G1 ^SG2 is {b ₄ }, and tasks t _G1 ^SG1 and t _G1 ^SG2 need to perform processing in block b ₄ read into the main memory, and block b ₄ is a common block Thus, the tasks t _G1 ^SG1 and t _G1 ^SG2 are processed in the common block b ₄ . When the processing of the task in the block b ₄ which is a common block is completed, it is not necessary to access the block b ₄ again, so the set B _G1 ^{SG1 (3)} , B _G1 ^{SG2 (3)} and the set {b ₄ } Find the difference set. ^Assuming that the values of the difference set are B _G1 ^{SG1 (4)} and B _G1 ^{SG2 (4)} , the following is obtained.
For task t _G1 ^SG1 : B _G1 ^{SG1 (3)} -{b ₄ } = {b ₅ } = B _G1 ^{SG1 (4)}
For task t _G1 ^SG2 : B _G1 ^{SG2 (3)} − {b ₄ } = {b ₅ } = B _G1 ^{SG2 (4)}

Finally, block b ₅ whose block relative address is 1024 is accessed from the disk, the data in block b ₅ is read into the main memory, and task t _G1 in the group excluding task t ₂ ¹ that has already been processed ^SG1, in order t _G1 ^SG2 determine whether it is necessary to perform processing at block b _5, represents a block b ₅ as a set {b _5}, the set {b _5} a set of blocks B _G1 ^{SG1 (4)} , B _G1 ^{SG2 (4)} , the product set is obtained as follows.
For task t _G1 ^SG1 : B _G1 ^{SG1 (4)} ∩ {b ₅ } = {b ₅ }
For task t _G1 ^SG2 : B _G1 ^{SG2 (4)} ∩ {b ₅ } = {b ₅ }
The product set for tasks t _G1 ^SG1 and t _G1 ^SG2 is {b ₅ }, and tasks t _G1 ^SG1 and t _G1 ^SG2 need to perform processing in block b ₅ read into the main memory, and block b ₅ is a common block Thus, tasks t _G1 ^SG1 and t _G1 ^SG2 are processed in the common block b ₅ . When the processing of the task in the block b ₅ which is a common block is finished, it is not necessary to access the block b ₅ again, so the set B _G1 ^{SG1 (4)} , B _G1 ^{SG2 (4)} and the set {b ₅ } Find the difference set. When the values of the obtained difference set are B _G1 ^{SG1 (5)} and B _G1 ^{SG2 (5)} , the following is obtained.
For task t _G1 ^SG1 : B _G1 ^{SG1 (4)} − {b ₅ } = {} = B _G1 ^{SG1 (5)}
For task t _G1 ^SG2 : B _G1 ^{SG2 (4)} − {b ₅ } = {} = B _G1 ^{SG2 (5)}
As a result, it can be seen that the sets B _G1 ^{SG1 (5)} and B _G1 ^{SG2 (5)} become empty sets {}, and the processing of the tasks t _G1 ^SG1 and t _G1 ^SG2 is completed. This is the end of the process.

  In this way, using the common block, the task processing in the group is performed at once without accessing the relation block in the disk many times, and the processing is performed in order from the task with the lowest processing cost. All task processing can be terminated by the last task processing.

FIG. 7 is a diagram illustrating how the tasks t ₂ ¹ , t _G1 ^SG1 , and t _G1 ^SG2 for the relation EMPLOYEE are processed using static multi-operation processing.
In FIG. 7, the processing of tasks t ₂ ¹ , t _G1 ^SG1 and t _G1 ^SG2 for the relation EMPLOYEE is accessed from a task with a low processing cost (from scan 1 to scan 3), and the processing result relations TEMP_T1_2 and TEMP_SG1_G1 , TEMP_SG2_G1 represents the result written.
A process (501) for processing a series of tasks accesses blocks in the disk by scan 1 with b ₂ , scan 2 with b ₁ , scan 3 with b ₃ , b ₄ , and b ₅ in order.
The process (501) processes the tasks in the group that need to be processed in each block to be accessed at one time, writes the processing result to the relation TEMP_T1_2, TEMP_SG1_G1, TEMP_SG2_G1, and the task in all blocks When the processing is completed, the task processing of the group G1 by static multi-operation processing is completed.

[(A-6) Sharing of processing result of composition selection calculation by tasks in subgroup]
In FIG. 7, the processing result TEMP_SG1_G1 (503) of the composition selection calculation task t _G1 ^SG1 includes all the processing results of the tasks t ₁ ³ , t ₃ ² , and t ₆ ^{3 in} the sub group. Tasks t ₁ ³ , t ₃ ² , and t ₆ ³ partially share the processing result TEMP_SG1_G1 (503) of the synthesis selection calculation task t _G1 ^SG2 .

The processing result TEMP_SG1_G1 (503) of the composite selection calculation task t _G1 ^SG1 shown in FIG. 7 is aligned with the value of the attribute BDATE used for the selection condition, and the individual tasks t ₁ ³ and t ₃ in the subgroup are arranged. ^2, t ₆ ³ of the processing result to the corresponding virtual relation TEMP_T3_1, TEMP_T2_3, represents how the TEMP_T3_6 is a record of the processing result TEMP_SG1_G1 partially shared. The attribute BDATE used in the selection condition of the composite selection operation is used to indicate that the tasks in the subgroup partially share the processing result TEMP_SG1_G1 of the composite-related operation task t _G1 ^SG1. Virtual relations TEMP_T3_1, TEMP_T2_3, and TEMP_T3_6 are created for the individual tasks t ₁ ³ , t ₃ ² , and t ₆ ³ in the subgroup as follows. In the virtual relation, record the processing result (relation) name of the compositing relation calculation task to be shared, and the storage location of the record sharing the processing result (the row range of the record, the block number and address where the record is stored) deep.
TEMP_T3_1 = {Relation: TEMP_SG1_G1; Row: 1-9; Block: b ₁ [0,256], b ₂ [256,512], b ₃ [512,768]};
TEMP_T2_3 = {Relation: TEMP_SG1_G1; Line: 13-16; Block: b ₄ [768,-]};
TEMP_T3_6 = {Relation: TEMP_SG1_G1; Row: 7-12; Block: b ₂ [256,512], b ₃ [512,768]};

Virtual relation TEMP_T3_1 is a processing result of the task t ₁ ³ in the subgroup SG1 _G1, synthetic relational operation block b ₁ of the processing result TEMP_SG1_G1 task t _G1 ^SG1, b _2, b ₃ are stored in record 1 This means that lines 9 through 9 are shared.
The virtual relation TEMP_T2_3 is a processing result of the task t ₃ ² in the subgroup SG1 _G1 , and indicates that the 13th to 16th rows of the record stored in the block b ₄ of the TEMP_SG1_G1 are shared.
Virtual relation TEMP_T3_6 is the task t ₆ ³ process results in the subgroup SG1 _G1, indicates that they share to 12 lines from seven lines of the record that is stored in the block b _2, b ₃ of TEMP_SG1_G1 ing.

[(A-7) Procedure for Sharing Processing Result of Composite Selection Operation]
In order for the individual selection calculation tasks in the subgroup to partially share the record of the relation obtained as a result of the processing of the composite selection calculation task using the virtual relation, the following procedure is used.
(I) Records in the processing result of the composite selection calculation task are aligned by the attribute values used in the selection conditions of the composite selection calculation.
(Ii) Scan the records in the sorted processing results to check whether each record satisfies the selection condition of each selection calculation task in the subgroup.
(Iii) In the processing result of the composite selection calculation task, record from which row to which row was a record within the selection range of each selection calculation task in the subgroup in the virtual relation that is the result of each processing. deep.

As described above, the tasks in the subgroup SG1 _G1 that partially share records from the processing result TEMP_SG1_G1 of the synthesis selection calculation t _G1 ^SG1 are as follows.
Subgroup 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

FIGS. 8A and 8B are represented in the file format of variable length record, variable block allocation (adjacent block allocation), and unspanned record (record that is not stored across two blocks). Combined selection calculation task t _G1 ^SG1 processing result TEMP_G1_SG1 (600) records are combined with two sort algorithms, merge sort and quick sort, based on the value of attribute BDATE used as the selection condition for the composite selection calculation. The virtual relations TEMP_T3_1, TEMP_T2_3, and TEMP_T3_6, which are the processing results of the selection operation tasks t ₁ ³ , t ₃ ² , and t ₆ ^{3 in} the subgroup SG1 _G1, are stored in the sorted processing results (613). It represents the procedure for partial sharing.

(1) First, a merge sort is applied, and the block sequence in the relation is recursively divided into two until the number of blocks becomes one (FIG. 8-1: 600 to 606).

(2) When the number of blocks in the block row becomes 1, the block row (FIG. 8-1: 603 to 606) cannot be further divided, so blocks b _{1 to} b ₄ in the block row are sequentially Read into main memory and arrange the records in the block based on the value of attribute BDATE. When aligning the records in the block, the variable-length records in the block have different sizes (because the number of bytes is different), so pointers (record addresses) to the individual records in the block (FIG. 8-1: 614 to 617) are arranged in the main memory, and the pointers arranged using the quick sort are arranged based on the value of the record having the pointer (the BDATE value of the record obtained from the address of the record).

(3) The records in the block are rearranged according to the order of the aligned pointers (FIG. 8-2: 618 to 621).

(4) When the records in the block are aligned, the next time when returning from the recall call by merge sort (FIG. 8-2: 607 to 613), the two aligned block sequences are combined into one block sequence. I will do it. When merging, the records to be merged are arranged in the sorted order.

(5) Finally, when two block strings (FIG. 8-2: 611, 612) are combined into one block string (613), each record is a selection operation task t in the subgroup SG1 _G1 . Whether the selection conditions ₁ ³ , t ₃ ² , and t ₆ ³ are satisfied is examined at a time.

(6) When all the records are arranged in the block sequence (FIG. 8-2: 613), among the records added to the block sequence (613) for tasks t ₁ ³ , t ₃ ² and t ₆ ³ Thus, it is recorded in the virtual relations TEMP_T3_1, TEMP_T2_3, and TEMP_T3_6 which record from which line to which line was within the selection range. Rather than adding actual records to the virtual relations TEMP_T3_1, TEMP_T2_3, and TEMP_T3_6, the storage locations of records that partially share the processing result (613) arranged as described above (the row range of records and those records are The stored block number and address) are recorded.

In this way, the selection computation tasks t ₁ ³ , t ₃ ² , t ₆ ³ in the subgroup SG1 _G1 can partially share the records in the processing result TEMP_G1_SG1 of the synthesis selection computation task t _G1 ^SG1. This is because the tasks B ₁ ³ , T ₃ ² , and T ₆ ³ use the attribute BDATE used to arrange the records in the result TEMP_G1_SG1 (613) as individual selection conditions. It is important that the work of examining the range sharing the record is performed when the record in the relation is finally formed into the block string (613) as in the method described above. The reason is that after finally aligning with the block column (613) and finding the shared range of the task records in the subgroup, all the records in the relation must be read again from the disk, This is because disk access is required.

  In addition, when there is no need to arrange the records in the processing result, that is, when the attribute used in the selection condition of the composite selection operation is the main attribute, the records in the processing result are stored in the already arranged order. Therefore, when adding a record to the processing result, it is checked at a time whether the selection conditions of the individual selection calculation tasks in the subgroup are satisfied.

As described above, when several selection calculation tasks collected in the subgroup are replaced with one synthesis selection calculation task t _G1 ^SG1 , the tasks t ₁ ³ and t ₃ ² in the sub group SG1 _G1 are performed. , T ₆ ³ will partially share the records in the processing result TEMP_SG1_G1, and the selection range between the individual tasks t ₁ ³ , t ₃ ² , t ₆ ^{3 in} the subgroup Since it is not necessary to separately create relations of processing results including overlapping records on the disk, the number of times the disk is accessed can be reduced, and the query processing speed can be improved.

  Another reason for creating a virtual relation and sharing the processing result of the synthesis selection calculation task is not to separately process the task for processing the processing result of the synthesis selection calculation task using the virtual relation. This is because processing is performed at once using multi-operation processing. Therefore, tasks that perform processing using virtual relations are not grouped based on virtual relations, but are grouped based on relations of processing results of synthetic relational calculation tasks that include virtual relations. The common block is found from the information recorded in the virtual relation, and the task processing in the group is performed at once.

  In this way, if task processing using virtual relations is performed at once, blocks in the processing result of the synthesis selection operation are accessed only once, so the number of disk accesses is reduced and query processing speed is improved. be able to.

[(A-8) Sharing of processing results of other composition-related operations]
The processing result TEMP_SG2_G1 of the composition related calculation task t _G1 ^SG2 of the group _G1 is shared by the tasks t ₄ ¹ and t ₅ ¹ in the subgroup SG2 _G1 . Since the composition-related operation task t _G1 ^SG2 is a join operation and the tasks t ₄ ¹ and t ₅ ¹ in the subgroup SG2 _G1 are the same task (t ₄ ¹ ≡t ₅ ¹ ), the processing result of the task t ₄ ¹ TEMP_T1_4 and task t ₅ ¹ processing result TEMP_T1_5 is the processing result TEMP_SG2_G1 synthetic relational operation task t _G1 ^SG2 as it would be used as a processing result of each task (TEMP_T1_4≡TEMP_T1_5≡TEMP_SG2_G1).

[(A-9) Creation of new group]
Using multi-operation processing, the processing of the composition-related operation tasks t _G1 ^SG1 and t _G1 ^{SG2 in the} group _G1 and the task t ₂ ¹ that does not gather in the subgroup is performed by the tasks t ₂ ¹ , t _G1 ^SG1 and t _G1 ^SG2 When the processing is completed in order, tasks that can be newly processed in the order of topological sort are found from the processing trees of FIGS. 4-1 to 4-3.
When the task t ₂ ¹ ends first, as can be seen from the processing tree P ₂ , processing of the task t ₂ ² can be newly started. Task t ₂ ² creates a new group G5 (in addition to the previous group G4) as a task for processing the processing result TEMP_T1_2 of task t ₂ ¹ , and adds task t ₂ ² to group G5 I will decide.

Next, when the processing of task t _G1 ^SG1 ends, the processing of tasks t ₁ ³ , t ₃ ² , t ₆ ³ in subgroup SG1 _G1 ends, and processing trees P ₁ , P ₃ , P ₆ As can be seen, the tasks t ₁ ⁴ , t ₃ ³ , and t ₆ ⁴ can be newly processed. Task ^{_{t 1 4, t 3 3,}} t 6 4 virtual relation is different for each access, but the task t ₁ ⁴ task t ₁ ³ of the processing result is a virtual relation TEMP_T3_1 include by are synthetic select operation task t _G1 accesses the processing result TEMP_SG1_G1 of ^SG1, it accesses the processing result TEMP_SG1_G1 task t ₃ ³ tasks t ₃ encompass a is virtual relation TEMP_T2_3 ² treatment results are synthetic select operation task t _G1 ^SG1, task t ₆ ⁴ Accesses the processing result TEMP_SG1_G1 of the synthesis selection calculation task t _G1 ^{SG1 including} the virtual relation TEMP_T3_6 that is the processing result of the task t ₆ ³ , so these new tasks t ₁ ⁴ , t ₃ ³ , t ₆ ⁴ Creates a new group G6 as a task for processing the common relation TEMP_SG1_G1, and adds tasks t ₁ ⁴ , t ₃ ³ , and t ₆ ⁴ to the group G6.

Finally, the processing of the task t _G1 ^SG2 is finished, it will be the processing of the task t ₄ ^1, t ₅ ¹ in the subgroup SG2 _G1 is completed, as can be seen from the processing tree P _4, P _5, Group G4 Since the processing of tasks t ₄ ² and t ₅ ² collected in (1) has not been completed, no new task can be found, so no group is created.

Summarizing the above, the relation of the processing results accessed by the tasks t ₂ ² , t ₁ ⁴ , t ₃ ³ , and t ₆ ⁴ newly found by the completion of the processing of the tasks in the group G1 is also obtained. At the same time, group G5 and group G6 are created as follows.
TEMP_T1_2: Group G5 = {t ₂ ² }
(t ₂ ² ) ： TEMP_T2_2 ← π _{SSN, LNAME, BDATE} TEMP_T1_2
TEMP_SG1_G1: Group 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

The group G5, will be the task t ₂ ² which performs processing for the task t ₂ ¹ processing result TEMP_T1_2 is collected, the group G6, processing for the processing result TEMP_SG1_G1 synthetic select operation task t _G1 ^SG1 Tasks t ₁ ⁴ , t ₃ ³ , and t ₆ ⁴ for performing are collected.

[(B) Processing of group G2]
Next, the processing of the composite projection operation task t _G2 ^{SG1 in the} group _G2 and the tasks t ₁ ¹ and t ₆ ¹ not collected in the subgroups are performed at once using multi-operation processing. As described above, each task in the group G2 is as follows.
DEPARTMENT: Group ^{_{G2 = {t G2 SG1, t}} 1 1, t 6 1}
(t _G2 ^SG1 ): TEMP_SG1_G2 ← π _{DNUMBER, DNAME, MGRSSN} DEPARTMENT
(t ₁ ¹ ): TEMP_T1_1 ← σ _{DPHONE = 23-3732} DEPARTMENT
(t ₆ ¹ ): TEMP_T1_6 ← σ _{DNUMBER = 7} DEPARTMENT

[(B-1) Access plan for each task]
First, the following access plans are created for the composite projection operation task t _G2 ^{SG1 in the} group _G2 and the tasks t ₁ ¹ and t ₆ ¹ that are not collected in the subgroup.
plan (t _G2 ^SG1 ): Scans DEPARTMENT and performs projection operation.
plan (t ₁ ¹ ): Search one record using the secondary index of DEPARTMENT.
plan (t ₆ ¹ ): Retrieves one record using the main index of DEPARTMENT.

[(B-2) Processing cost of each task]
When an access plan is created for each task, the processing cost of each task is calculated based on the access plan.
Task t _G2 ^SG1 processing cost: cost (t _G2 ^SG1 ) = b _D = 5
Task t ₁ ¹ processing cost: cost (t ₁ ¹ ) = x _D2 + 1 = 3
Task t ₆ ¹ processing cost: cost (t ₆ ¹ ) = x _D1 + 1 = 2
The processing cost of the task t _G2 ^SG1 is b _D = 5 because it is a processing cost for accessing all blocks in the relation in order to scan the relation DEPARTMENT and perform the projection operation.

The processing cost of task t ₁ ^{1 is} the processing cost for searching one record using the secondary index (102) of the relation DEPARTMENT. This is the level x _{D2 of the} secondary index and the processing cost of accessing the block. Since the level x _D2 of the secondary index (102) of the relation DEPARTMENT in FIG. 3A is 2, the processing cost is x _D2 +1. = 3.
Processing cost of the task t ₆ ¹ is a processing cost for searching a single record using the primary index of the relation DEPARTMENT (100). x _D1 +1 is the level x _{D1 of} the index accessed to find the target data using the primary index (100) of the relation DEPARTMENT and the processing cost of accessing the current block. Level of the main index (100) of the relation DEPARTMENT in Figure 3-1 because it is 1 (x _D1 = 1 next), the processing cost of the task t ₆ ¹ are x _D1 + 1 = 2.

When the processing cost is calculated as described above, the tasks in the group are rearranged from the processing cost in the descending order based on the processing cost.
sort (t _G2 ^SG1 , t ₁ ¹ , t ₆ ¹ ) ⇒ (t ₆ ¹ , t ₁ ¹ , t _G2 ^SG1 )

[(B-3) Block set corresponding to each task]
To the task _{^{t 6 1, t 1 1,}} t G2 SG1, using an index, all blocks that need to be accessed examined beforehand, block set B ₆ ¹ corresponding to each task, B ₁ ¹ , B _G2 ^SG1 is collected as follows.
For task t ₆ ¹ : B ₆ ¹ = {b ₂ }
For task t ₁ ¹ : B ₁ ¹ = {b ₅ }
For task t _G2 ^SG1 : B _G2 ^SG1 = {b ₁ , b ₂ , b ₃ , b ₄ , b ₅ }
Thus, can be found block sets _{^{B 6 1, B 1 1,}} B G2 SG1 corresponding to each task _{^{t 6 1, t 1 1,}} t G2 SG1 , since based on the reasons below It is.
Task t ₆ ^1, it is necessary records that meet the selection condition "DNUMBER = 7". Using the primary index of the relation DEPARTMENT, you can see that the record with attribute DNUMBER value 7 is stored in block b ₂ with a relative block address of 256, and only block b ₂ needs to be accessed. Therefore, the set of blocks that need to be accessed in order to perform the process of task t ₆ ¹ is {b ₂ }.

The task t ₁ ¹ needs a record that satisfies the selection condition “DPHONE = 23-3732”. Using the secondary index of the relation DEPARTMENT, we can see that the record with attribute DPHONE value 233-3732 is stored in block b ₅ with a relative block address of 1024, and only block b ₅ is accessed. Therefore, the set of blocks that need to be accessed to perform the processing of task t ₁ ¹ is {b ₅ }.
Task t _G2 ^SG1, in order to perform the projection operation process, since it is necessary to access the block from the first block b ₁ in the relation DEPARTMENT until the last block b _5, the processing of the task t _G2 ^SG1 The block set that needs to be accessed in order to do is {b ₁ , b ₂ , b ₃ , b ₄ , b ₅ }.

[(B-4) Determination of order of blocks to be accessed (common blocks)]
As described above, after finding a block set corresponding to each task, each task is in order from a task with a low processing cost to a task with a high processing cost, that is, in order of tasks t ₆ ¹ , t ₁ ¹ , t _G2 ^SG1. Let's find the union of the block set corresponding to the task.
First, as TB ₀ = {} (empty set), a block set B ₆ ¹ and a union set TB ₆ ¹ corresponding to TB ₀ and task t ₆ ¹ are obtained. Then, the sum set TB ₁ ¹ set of blocks B ₁ ¹ corresponding to the TB ₆ ¹ and task t ₁ ^1. Furthermore, the TB ₁ ¹ and when the sum set TB _G2 ^SG1 of the block set B _G2 ^SG1 corresponding to the task t _G2 ^SG1 as follows. In this case, when obtaining the union, the newly added set is added last in the union.
TB ₀ = {}
Union set with set B ₆ ¹ corresponding to task t ₆ ¹ : TB ₆ ¹ = TB ₀ ∪B ₆ ¹ = {b ₂ }
Union set with set B ₁ ¹ corresponding to task t ₁ ¹ : TB ₁ ¹ = TB ₆ ¹ ∪B ₁ ¹ = {b ₂ , b ₅ }
The union of the set B _G2 ^SG1 corresponding to task t _G2 ^SG1 : TB _G2 ^SG1 = TB ₁ ¹ ∪B _G2 ^SG1 = {b ₂ , b ₅ , b ₁ , b ₃ , b ₄ }

As described above, when the union is obtained in order from the block set corresponding to the task with the low processing cost to the block set corresponding to the task with the high processing cost, the last task (the task with the highest processing cost) From the union TB _G2 ^SG1 with the block set corresponding to, access should be started from block b _{2 of} the disk and access terminated at block b ₄ , and access to the blocks in the relation DEPARTMENT on the disk The order can be determined as (b ₂ , b ₅ , b ₁ , b ₃ , b ₄ ). The reason for obtaining the union by this method is to determine the order in which blocks in the disk should be accessed in order from the task with the lowest processing cost. Since the thus blocking b _{2 obtained, b 5, b 1, b} 3, b 4 , can be shared when sequentially processes the task ^{_{t 6 1, t 1 1,}} t G2 SG1 in order, These blocks are called common blocks.

Looking at the blocks included in the block set B ₆ ¹ , B ₁ ¹ , B _G2 ^SG1 described above, the block b ₂ is used to process the tasks t ₆ ¹ , t _G2 ^SG1 and the block b It can be seen that ₅ is used to process tasks t ₁ ¹ , t _G2 ^SG1 and blocks b ₁ , b ₃ , b ₄ are used to process tasks t _G2 ^SG1 . If these blocks are handled as common blocks, tasks that require these common blocks can be processed at once on the common block. The following table summarizes the above.

[(B-5) Task processing in common block]
As described above, in order to find out what kind of task is processed in each common block, the block sets B ₆ ¹ , B created for the tasks t ₆ ¹ , t ₁ ¹ , t _G2 ^SG1 are used. ₁ ¹ , B _G2 Based on ^SG1 information, the following procedure should be used.
First, block b ₂ whose block relative address is 256 is accessed from the disk, the data in block b ₂ is read into the main memory, and tasks t ₆ ¹ , t ₁ ¹ and t _G2 ^SG1 in the group block. to investigate whether it is necessary to perform processing in b _2, represents the block b ₂ as a set {b _2}, and the set {b _2} a set of blocks ^{_{B 6 1, B 1 1,}} B G2 SG1 The product set (Intersection) between them is as follows.
For task t ₆ ¹ : B ₆ ¹ ∩ {b ₂ } = {b ₂ }
For task t ₁ ¹ : B ₁ ¹ ∩ {b ₂ } = {}
For task t _G2 ^SG1 : B _G2 ^SG1 ∩ {b ₂ } = {b ₂ }

The product set for tasks t ₆ ¹ and t _G2 ^SG1 excluding task t ₁ ¹ is {b ₂ }, and tasks t ₆ ¹ and t _G2 ^SG1 need to perform processing in block b ₂ read into the main memory. As will be apparent, the block b ₂ becomes a common block, and each task is processed in the common block b ₂ . When the processing of the task in the common block block b ₂ is completed, it is not necessary to access the block b ₂ again, so the difference set (Difference) between the set B ₆ ¹ , B _G2 ^SG1 and the set {b ₂ } is obtained. . When the obtained difference set values are B ₆ ^{1 (1)} and B _G2 ^{SG1 (1)} , the following is obtained.
To the task ^{_{t 6 1: B 6 1 -}} {b 2} = {} = B 6 1 (1)
For task t _G2 ^SG1 : B _G2 ^SG1 − {b ₂ } = {b ₁ , b ₃ , b ₄ , b ₅ } = B _G2 ^{SG1 (1)}
As a result, it can be seen that the set B ₆ ^{1 (1)} processing of the task t ₆ ¹ empty set {} is completed.

Next, the block b ₅ whose block address is 1024 is accessed from the disk, the data in the block b ₅ is read into the main memory, and the task t ₁ in the group excluding the task t ₆ ¹ that has already been processed. ^1, in order to t _G2 ^SG1 determine whether it is necessary to perform processing at block b _5, represents a block b ₅ as a set _{{b 5}, {b 5} } and a set of blocks B ₁ ^1, B _G2 ^SG1 Finding the product set with ⁽¹⁾ is as follows.
For task t ₁ ¹ : B ₁ ¹ ∩ {b ₅ } = {b ₅ }
For task t _G2 ^SG1 : B _G2 ^{SG1 (1)} ∩ {b ₅ } = {b ₅ }

The product set for tasks t ₁ ¹ and t _G2 ^SG1 is {b ₅ }, and it is necessary to perform processing in block b ₅ that tasks t ₁ ¹ and t _G2 ^SG1 read into the main memory, and block b ₅ is a common block Thus, the tasks t ₁ ¹ and t _G2 ^SG1 are processed in the common block b ₅ . When the processing of the task in the block b ₅ which is a common block is completed, it is not necessary to access the block b ₅ again, so that the difference set between the set B ₁ ¹ , B _G2 ^{SG1 (1)} and the set {b ₅ } is obtained. Ask. Assuming that the values of the obtained difference set are B ₁₁ ⁽¹⁾ and B _G2 ^{SG1 (2)} , the following is obtained.
For task t ₁ ¹ : B ₁ ¹ − {b ₅ } = {} = B ₁ ^{1 (1)}
For task t _G2 ^SG1 : B _G2 ^{SG1 (1)} − {b ₅ } = {b ₁ , b ₃ , b ₄ } = B _G2 ^{SG1 (2)}
As a result, it can be seen that the set B ₁ ^{1 (1)} becomes an empty set {} and the processing of the task t ₁ ¹ is completed. At this stage, since the remaining tasks in the group and only the t _G2 ^SG1, it performs processing tasks t _G2 ^SG1 to access the blocks b _1, b _3, b ₄ remaining from relation DEPARTMENT, task t _G2 ^SG1 When the processing is completed, the processing of all tasks in the group is completed.

9, using the static multi-operation processing, the task _{^{t 6 1, t 1 1,}} t G2 SG1 state sequentially processes accessing the cost of small tasks (for Scan 1 Scan 5) for the relation DEPARTMENT and It is a figure showing the result of having written the processing result in relation TEMP_T1_6 (704), TEMP_T1_1 (703), and TEMP_SG1_G2 (705).
A process (701) for processing a series of tasks accesses the blocks in the disk in the order of blocks b ₂ , b ₅ , b ₁ , b ₃ , and b ₄ as shown in FIG. When the tasks in the group that need to be processed in that block are processed, the processing results are written to the relations TEMP_T1_6 (704), TEMP_T1_1 (703), and TEMP_SG1_G2 (705). The task processing of group G2 by static multi-operation processing has been completed.

[(B-6) Creation of processing result of composite projection operation task]
The processing result TEMP_SG1_G2 of the composite projection calculation task t _G2 ^SG1 is partially shared by the projection calculation tasks t ₂ ³ and t ₃ ¹ in the subgroup SG1 _G2 . As described above, the tasks in the subgroup SG1 _G2 are as follows.
Subgroup SG1 _G2 = {t ₂ ³ , t ₃ ¹ }
(t ₂ ³ ) ： TEMP_T3_2 ← π _{DNUMBER, DNAME, MGRSSN} DEPARTMENT
(t ₃ ¹ ) ： TEMP_T1_3 ← π _{DNUMBER, DNAME} DEPARTMENT
To partially share the attribute (column) in the processing result TEMP_SG1_G2 of the composite projection operation task t _G2 ^SG1 with the projection operation tasks t ₂ ³ and t ₃ ¹ in the subgroup SG1 _G2 , the composite projection operation task t _G2 ^SG1 When the above process is performed, the virtual relations TEMP_T3_2 and TEMP_T1_3 shown in FIG. 9 are created for the tasks t ₂ ³ and t ₃ ¹ in the subgroup SG1 _G2 sharing the processing result TEMP_SG1_G2. In the virtual relation, the processing result (relation) name of the compositing projection operation to be shared and the storage position (column number) of the attribute sharing the processing result are recorded as follows.
TEMP_T3_2 = {Relation: TEMP_SG1_G2; Column: 1,2,3};
TEMP_T1_3 = {Relation: TEMP_SG1_G2; Column: 1,2};

Virtual relation TEMP_T3_2 is a processing result of the task t ₂ ³ in the subgroup SG1 _G2, share columns 1, 2 and 3 of the processing result TEMP_SG1_G2 synthetic project operation task t _G2 ^SG1.
The virtual relation TEMP_T1_3 is the processing result of the task t ₃ ¹ in the subgroup SG1 _G2 , and shares the columns 1 and 2 of the processing result TEMP_SG1_G2 of the composite projection operation task t _G2 ^SG1 .
As described above, a number of projection calculation tasks collected in the subgroup are replaced with one composite projection calculation task t _G2 ^SG1 , and tasks t ₂ ³ and t ₃ ¹ in the subgroup SG1 _G2 are The attribute (column) in the processing result TEMP_SG1_G2 will be partially shared through the virtual relation, and the records that overlap the attributes projected to the individual tasks t ₂ ³ and t ₃ ¹ in the subgroup are included. Since it is not necessary to separately create relations of processing results on the disk, it is possible to reduce the number of times of accessing the disk and improve the query processing speed.

The processing result TEMP_SG1_G2 (705) of the composite projection calculation task t _G2 ^SG1 in FIG. When creating a processing result of a composite relational operation task using multi-operation processing, if the search process is performed on a record in the processing result of the composite relational calculation task by a task such as a join operation, the search process Create an index for the attribute used for.

The records in the processing result TEMP_SG1_G2 (705) of the composite projection operation task t _G2 ^SG1 in FIG. 9 are processed after the processing of the tasks t ₂ ³ and t ₃ ¹ in the subgroup SG1 _G2 is completed. As shown in the processing tree, an index (702) is created for the attribute DNUMBER used for the search processing because the search is performed by the join operation tasks t ₂ ⁶ and t ₃ ⁴ . Join operation task t ₂ ⁶ is a task that performs a search process on virtual relation TEMP_T3_2, and join operation task t ₃ ⁴ is a task that performs a search process on virtual relation TEMP_T1_3, and virtual relation TEMP_T3_2 and virtual relation TEMP_T1_3 are Since the attribute (column) in the relation TEMP_SG1_G2 (705) is partially shared, the index (702) created for the relation TEMP_SG1_G2 is used for the search processing of the join operation tasks t ₂ ⁶ and t ₃ ⁴ Will be shared. Task t ₂ ⁶ uses the index (702) to search for a record from the relation TEMP_SG1_G2 (705). . Similarly, task t ₃ ⁴ retrieves a record from relation TEMP_SG1_G2 (705) using index (702), and retrieves a record from virtual relation TEMP_T1_3 when the retrieved record is included in virtual relation TEMP_T1_3. It will be. When a record is retrieved, only the necessary attributes (columns) recorded in the individual virtual relations are projected from the retrieved record.

  In this way, if an index is created for the processing result of the composition-related calculation task, tasks that search records for the virtual relation can share the index, and individual virtual relations can be shared. Therefore, it is not necessary to create an index separately, so that the number of times the disk is accessed can be reduced and the query processing speed can be improved.

[(B-7) Creation of new group]
Processing of the task t _{6 ^1,} t ^{1 1} not gather the synthetic project operation task t _G2 ^SG1 and subgroups in the group G2 by using multi-operation processing utilizing a synthetic relational operation as described above is the task t ₆ ¹ , t ₁ ¹ , t _G2 ^SG1 is completed in this order, and when an index is created for the processing result TEMP_SG1_G2 of the composite projection operation task t _G2 ^SG1 , topological from the processing tree of FIGS. 4-1 to 4-3 Tasks that can be newly processed in the sort order will be found.

First, when the task t ₆ ¹ is completed, the processing of the task t ₆ ² can be newly started as can be seen from the processing tree P ₆ . Task t ₆ ² will be added to the task t ₆ ² group G7 by creating a new group G7 as a task for performing a process to the task t ₆ ¹ processing result TEMP_T1_6.
Next, when the task t ₁ ¹ is completed, the processing of the task t ₁ ² can be newly started as can be seen from the processing tree P ₁ . Task t ₁ ² will be added to the task t ₁ ² the group G8 to create a new group G8 as a task for performing a process to the task t ₁ ¹ processing result TEMP_T1_1.

Finally, when the processing of the task t _G2 ^SG1 is finished, the processing of the tasks t ₂ ³ and t ₃ ¹ in the subgroup SG1 _G2 is finished. As can be seen from the processing trees P ₂ and P ₃ , the group G3 Since the processing of task t ₂ ⁴ collected in (1) and the processing of task t ₃ ³ collected in group G6 have not been completed, no new task can be found, so no group is created.
To summarize the above, based on the relation of the processing results for accessing the tasks t ₆ ² and t ₁ ² newly found by the completion of the processing of the tasks in the group G2, the group G7, Group G8 is created.
TEMP_T1_6: Group G7 = {t ₆ ² }
(t ₆ ² ): TEMP_T2_6 ← π _{DNUMBER, DNAME} TEMP_T1_6
TEMP_T1_1: Group G8 = {t ₁ ² }
(t ₁ ² ) ： TEMP_T2_1 ← π _{DNUMBER, DNAME} TEMP_T1_1
The group G7, so that the task t ₆ ² which performs processing for the task t ₆ ¹ processing result TEMP_T1_6 is collected. The group G8, so that the task t ₁ ² for performing processing for the task t ₁ ¹ processing result TEMP_T1_1 is collected.

[(C) Processing of group G3]
When the process of the group G2 is completed, the process of the synthesis selection calculation task t _G3 ^SG1 in the group G3 is performed next. As described above, the synthesis selection calculation task in the group G3 is as follows.
PROJECT: Group G3 = {t _G3 ^SG1 }
(t _G3 ^SG1 ) ： TEMP_SG1_G3 ← σ _{PLOCATION = 'New York' AND (PNAME = 'Aquarius' OR PNAME = 'Stafford')} PROJECT
Since there is only one task in the group G3, the synthesis selection calculation task t _G3 ^SG1 is directly processed. When the process of the composite selection calculation task t _G3 ^SG1 is completed, a processing result TEMP_SG1_G3 including about two records in which PLOCATON is New York and PNAME is 'Aquarius' or 'Stafford' is created. Records in the processing result TEMP_SG1_G3 are arranged by the value of the attribute PNAME, and the following virtual relation is created for the tasks t ₁ ⁷ and t ₂ ⁴ in the subgroup SG1 _G3 .
TEMP_T7_1 = {Relation: TEMP_SG1_G3; Line: 1; Block: b ₁ };
TEMP_T4_2 = {Relation: TEMP_SG1_G3; Line: 2; Block: b ₁ };
Virtual relation TEMP_T7_1 is a processing result of the task t ₁ ⁷ subgroup SG1 within _G3, so that the value of the attribute PNAME stored in the block b ₁ of TEMP_SG1_G3 share the first row of records is Aquarius .

Virtual relation TEMP_T4_2 is the task t ₂ ⁴ processing result subgroup SG1 within _G3, so that the value of the attribute PNAME stored in the block b ₁ of TEMP_SG1_G3 share the second row of records is Stafford .
When the processing of the composite selection calculation task t _G3 ^SG1 in the group G3 is completed, the processing of the tasks t ₁ ⁷ and t ₂ ⁴ in the subgroup SG1 _G3 is completed, as shown in FIGS. As can be seen from the processing trees P ₁ and P ₂ , the tasks t ₁ ⁸ and t ₂ ⁵ can be newly processed.
The tasks t ₁ ⁸ and t ₂ ⁵ have different virtual relations to be accessed, but the task t ₁ ⁸ receives the processing result TEMP_SG1_G3 of the synthesis selection calculation task t _G3 ^SG1 through the virtual relation TEMP_T7_1 that is the processing result of the task t ₁ ^7. access task t ₂ ^5, through virtual relation TEMP_T4_2 a processing result of the task t ₂ ^4, it means that access to the processing result TEMP_SG1_G3 synthetic select operation task t _G3 ^SG1, processing with respect to the common relation TEMP_SG1_G3 As a task to perform, a new group G9 is created, and tasks t ₁ ⁸ and t ₂ ⁵ are added to group G9.

In summary, the tasks t ₁ ⁸ and t ₂ ⁵ found by completing the task processing in the group G3 are collected in the group G9 as follows.
TEMP_SG1_G3: Group G9 = {t ₁ ⁸ , t ₂ ⁵ }
(t ₁ ⁸ ): TEMP_T8_1 ← π _{PNUMBER, PNAME} TEMP_T7_1
(t ₂ ⁵ ) ： TEMP_T5_2 ← π _{PNUMBER, PNAME, DNUM} TEMP_T4_2

[(D) Group G4 processing]
Next, by applying multi-operation processing, the tasks t ₁ ⁹ , t ₄ ² and t ₅ ² in the group G4 are processed at once. As described above, each task in the group G4 is as follows.
WORKS_ON: Group G4 = {t ₁ ⁹ , t ₄ ² , t ₅ ² }
(t ₁ ⁹ ) ： TEMP_T9_1 ← π _{ESSN, PNO} WORKS_ON
(t ₄ ² ) ： TEMP_T2_4 ← PROJECT | X | _{PNUMBER = PNO} WORKS_ON
(t ₅ ² ): TEMP_T2_5 ← σ _{HOURS <10} WORKS_ON
Here, the description of the processing of tasks t ₁ ⁹ , t ₄ ² , and t ₅ ² in G4 by multi-operation processing is omitted. When multi by operation processing in the group G4 task t ₁ ^9, t ₄ ^2, performs t ₅ ² processing tasks that can be newly processed in the order from the processing tree topological sort of FIG. 4-1 to Figure 4-3 Will be found.

First, when the processing of task t ₁ ⁹ is completed, as can be seen from the processing tree P _1, since the processing of task t ₁ ⁸ in group G9 has not ended, a task that can be newly processed is not found. The group remains uncreated.
Next, when the processing of task t ₄ ² ends, as can be seen from the processing tree P ₄ , the processing of task t ₄ ¹ in group G1 has already ended, so the processing of task t ₄ ^{3 is} newly started. Will be able to. Task t ₄ ³ is a task that performs a join operation using the processing result TEMP_T1_4 of task t ₄ ^{1 and} the processing result TEMP_T2_4 of task t ₄ ² . Because it uses TEMP_T2_4 the join operation search source, newly create a group G10 as a task for performing processing for the processing result TEMP_T2_4, to the addition of the task t ₄ ³ group G10.

Finally, when the processing of task t ₅ ² is completed, as can be seen from the processing tree P ₅ , the processing of task t ₅ ¹ in group G1 has already ended, so a new processing of task t ₅ ³ is started. Will be able to. Task t ₅ ³ is a task for processing the join operation using a processing result TEMP_T1_5 and task t ₅ ² of the processing result TEMP_T2_5 task t ₅ ^1. Because it uses TEMP_T2_5 the join operation search source, newly create a group G11 as a task for performing processing for the processing result TEMP_T2_5, to be added to the task t ₅ ³ group G11.
To summarize the above, the tasks t ₄ ³ and t ₅ ³ found by the completion of the processing of tasks t ₁ ⁹ , t ₄ ² and t ₅ ² in the group G4 are divided into groups as follows. Will do. Since the processing result of task t ₄ ³ is the final processing result of query Q ₄ , it will be expressed as RESULT_Q ₄ . Processing results Task t ₅ ^3, since the final processing result of the query Q _5, to be represented by RESULT_Q5.
TEMP_T2_4: Group G10 = {t ₄ ³ }
(t ₄ ³ ): RESULT_Q4 ← TEMP_T1_4 | X | _{SSN = ESSN} TEMP_T2_4
TEMP_T2_5: Group G11 = {t ₅ ³ }
(t ₅ ³ ): RESULT_Q5 ← TEMP_T1_5 | X | _{SSN = ESSN} TEMP_T2_5

[(E) Group G5 processing]
When the processing of the group G4 is completed, the processing of the group G5 is performed next. As described above, the tasks in the group G5 are as follows.
TEMP_T1_2: Group G5 = {t ₂ ² }
(t ₂ ² ) ： TEMP_T2_2 ← π _{SSN, LNAME, BDATE} TEMP_T1_2
Not present only one task t ₂ ² The group G5, the task t ₂ ² is a task for processing project operation to the task t ₂ ¹ processing result TEMP_T1_2. Thus, when only one task exists in the group, the task t ₂ ² in the group G5 is directly processed.
When the processing of the task t ₂ ² is completed, as can be seen from the processing tree P ₂ in Figure 4-2, the processing of the task t ₂ ⁵ in the group G9 is not completed, the task t ₂ which is not collected into groups ^Since the processing of ⁶ and t ₂ ⁷ has not been completed, no new task can be found and no group is created.

When the process of group G5 is completed, the process of group G6 is performed next. In the group G6, tasks for processing the processing result TEMP_SG1_G1 of the composition selection calculation task t _G1 ^SG1 are collected, and will be described in detail.

  The task processing that has been handled so far has been task processing for database relations such as database relations EMPLOYEE, DEPARTMENT, PROJECT, and WORKS_ON. Next, the task processing for the relation obtained as a result of the processing of the composition relation calculation task, not the database relation, will be described.

[(F) Process of group G6 (task process for the relation obtained as a result of the process of the composition relation calculation task)]
Using multi-operation processing, tasks t ₁ ⁴ , t ₃ ³ , and t ₆ ⁴ in group G6 are processed at once. As described above, the tasks in the group G6 are as follows.
TEMP_SG1_G1: Group 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

[(F-1) Access plan for each task]
Based on the static multi-operation processing method, an access plan is created for each task t ₁ ⁴ , t ₃ ³ , t ₆ ⁴ in the group G6. The blocks accessed by the task are examined from the virtual relation TEMP_T3_1 used for the processing of task t ₁ ^4, the virtual relation TEMP_T2_3 used for the processing of task t ₃ ³ , and the virtual relation TEMP_T3_6 used for the processing of task t ₆ ^4. . As described above, in the virtual relations TEMP_T3_1, TEMP_T2_3, and TEMP_T3_6, the block number and address sharing the processing result TEMP_SG1_G1 of the synthesis selection calculation task t _G1 ^SG1 are already recorded, so which block should be accessed in advance. I understand how. The access plans for tasks t ₁ ⁴ , t ₃ ³ , and t ₆ ⁴ are as follows.
plan (t ₁ ⁴ ): Access the blocks b ₁ , b ₂ , and b ₃ of TEMP_SG1_G1 to perform the projection operation.
plan (t ₃ ³ ): Access the block b ₄ of TEMP_SG1_G1 to perform the projection operation.
plan (t ₆ ⁴ ): Access the blocks b ₂ and b ₃ of TEMP_SG1_G1 to perform the projection operation.

[(F-2) Processing cost of each task]
When the processing cost of each task is calculated based on the access plan, it can be expressed as follows.
Processing cost of the task ^{_{t 1 4: cost (t 1}} 4) = 3
Task t ₃ ³ processing cost: cost (t ₃ ³ ) = 1
Task t ₆ ⁴ processing cost: cost (t ₆ ⁴ ) = 2
Processing cost of the task t ₁ ⁴ is a relation TEMP_SG1_G1 3 single block b ₁ relative address block is 0,256,512 from, b _2, b ₃ 3 Since processing cost for processing the project operation by accessing the is there.
The processing cost of the task t ₃ ³ is 1 because it is a processing cost for accessing the block b ₄ whose relative address is 768 from the relation TEMP_SG1_G1 and performing the projection operation.
The processing cost of task t ₆ ⁴ is 2 because it is a processing cost for accessing the _two blocks b ₂ and b ₃ whose relative addresses of the blocks are 256 and 512 from the relation TEMP_SG1_G1 and performing the projection operation. When the processing costs are calculated as described above, the tasks in the group are rearranged in order of increasing processing costs based on the processing costs as follows.
sort (t ₁ ⁴ , t ₃ ³ , t ₆ ⁴ ) ⇒ (t ₃ ³ , t ₆ ⁴ , t ₁ ⁴ )

[(F-3) Block set corresponding to each task]
Based on the information in the virtual relation are recorded, the task _{^{t 3 3, t 6 4,}} t 1 4 examines certain block need to be accessed from relation TEMP_SG1_G1, block set B ₃ ³ corresponding to each task, When collected in B ₆ ^4, B ₁ ^4, as follows.
Union set with set B ₃ ³ corresponding to task t ₃ ³ : B ₃ ³ = {b ₄ }
Union set with set B ₆ ⁴ corresponding to task t ₆ ⁴ : B ₆ ⁴ = {b ₂ , b ₃ }
The union with the set B ₁ ⁴ corresponding to the task t ₁ ⁴ : B ₁ ⁴ = {b ₁ , b ₂ , b ₃ }

[(F-4) Determination of order of blocks to be accessed (common blocks)]
As described above, after the finding block set corresponding to each task, in order to process cost greater task from a small task of processing cost, i.e. in the order of the task _{^{t 3 3, t 6 4,}} t 1 4 each Let's find the union of the block set corresponding to the task.
First, as TB ₀ = {} (empty set), a block set B ₃ ³ and a union set TB ₃ ³ corresponding to TB ₀ and task t ₃ ³ are obtained. Then, the sum set TB ₆ ⁴ of the block set B ₆ ⁴ corresponding to the TB ₃ ³ and task t ₆ ^4. Further, when finding the TB ₆ ⁴ and union TB ₁ ⁴ the block set B ₁ ⁴ corresponding to the task t ₁ ⁴ is as follows. In this case, when obtaining the union, the newly added set is added last in the union.
TB ₀ = {}
For task t ₃ ³ : TB ₃ ³ = TB ₀ ∪B ₃ ³ = {b ₄ }
For task t ₆ ⁴ : TB ₆ ⁴ = TB ₃ ³ ∪B ₆ ⁴ = {b ₄ , b ₂ , b ₃ }
For task t ₁ ⁴ : TB ₁ ⁴ = TB ₆ ⁴ ∪B ₁ ⁴ = {b ₄ , b ₂ , b ₃ , b ₁ }

Set TB ₁ ⁴ from the block in the relation _{TEMP_SG1_G1 b 4, b 2, b} 3, b it can be seen that it should be accessible in _one order. Looking at the blocks included in the block set ^{_{B 3 3, B 6 4,}} B 1 4 described above, the block b ₄ is used to process the task t ₃ ^3, block b _2, the task is used to process t ₆ ^4, t ₁ ^4, block b ₃ is used to process the task t ₆ ^4, t ₁ ^4, block b _1, in order to handle tasks t ₁ ⁴ It can be seen that it is used. If these blocks are handled as common blocks, tasks that require these common blocks can be processed at once on the common block. The following table summarizes the above.

[(f-5) Task processing in common block]
As described above, in order to find what tasks are processed in each common block, the task _{^{t 3 3, t 6 4,}} t 1 4 block set B ₃ ³ created for, B ₆ ^4, B based on ₁ ⁴ information, then the procedure may be used as described.
First, the block b ₄ relative address of the block is 768 to access the disk to read the data in the block b ₄ to the main memory, the task t ₃ ³ in the group, t ₆ ^4, t ₁ ⁴ block to investigate whether it is necessary to perform processing with b _4, it represents a block b ₄ as a set {b _4}, block set _{^{B 3 3, B 6 4,}} B 1 4 , respectively intersection Request (intersection).
For task t ₃ ³ : B ₃ ³ ∩ {b ₄ } = {b ₄ }
For task t ₆ ⁴ : B ₆ ⁴ ∩ {b ₄ } = {}
For task t ₁ ⁴ : B ₁ ⁴ ∩ {b ₄ } = {}

Since the product of the set for task t ₃ ³ excluding tasks t ₆ ⁴ and t ₁ ⁴ is not an empty set {}, the process of task t ₃ ³ is performed on each record in block b ₄ read into the main memory. . When the processing in the block b ₄ is completed, it is not necessary to access the block b ₄ again. Therefore, a difference between the set B ₃ ³ and the set {b ₄ } is obtained, and the value of the obtained difference set is set to B ₃ ^{3 (1)} is as follows.
For task t ₃ ³ : B ₃ ³ − {b ₄ } = {} = B ₃ ^{3 (1)}
It can be seen that the set B ₃ ^{3 (1)} becomes an empty set {} and the processing of the task t ₃ ³ is finished.
Next, the block b ₂ whose block relative address is 256 is accessed from the disk, the data in the block b ₂ is read into the main memory, and the task t ₆ in the group excluding the task t ₃ ³ that has already been processed. ^4, t ₁ ⁴ to determine whether it is necessary to perform processing at block b _2, represents the block b ₂ as a set {b _2}, the set {b _2} with the block sets B ₆ ^4, B ₁ ⁴ The product set between and is obtained as follows.
For task t ₆ ⁴ : B ₆ ⁴ ∩ {b ₂ } = {b ₂ }
For task t ₁ ⁴ : B ₁ ⁴ ∩ {b ₂ } = {b ₂ }

Task t ₆ ^4, t ₁ intersection for ⁴ {b _2}, and the it is necessary to task t ₆ ^4, t ₁ ⁴ performs processing in block b ₂ read into the main memory, the block b ₂ common block next, so that the processing of the task t ₆ ^4, t ₁ ⁴ in a common block b _2. When the processing of tasks in the block b ₂ is a common block is completed, since there is no need to re-access the block b _2, we obtain the set difference of the set {b _2} the set B ₆ ^4, B ₁ ^4. When the values of the obtained difference set are B ₆ ^{4 (1)} and B ₁₄ ⁽¹⁾ , the following is obtained.
For task t ₆ ⁴ : B ₆ ⁴ − {b ₂ } = {b ₃ } = B ₆ ^{4 (1)}
For task t ₁ ⁴ : B ₁ ⁴ − {b ₂ } = {b ₁ , b ₃ } = B ₁ ^{4 (1)}

Next, the block b ₃ whose block relative address is 512 is accessed from the disk, the data in the block b ₃ is read into the main memory, and the task t ₆ in the group excluding the task t ₃ ³ that has already been processed. ^4, t ₁ ⁴ to determine whether it is necessary to perform processing at block b _3, represents the block b ₃ as a set {b _3}, the set {b _3} and block set B ₆ ^{4 (1),} Finding the product set with B ₁ ^{4 (1)} is as follows.
For task t ₆ ⁴ : B ₆ ^{4 (1)} ∩ {b ₃ } = {b ₃ }
For task t ₁ ⁴ : B ₁ ^{4 (1)} ∩ {b ₃ } = {b ₃ }
Task t ₆ ^4, t ₁ intersection for the ⁴ {b _3}, and the it is necessary to task t ₆ ^4, t ₁ ⁴ performs processing in block b ₃ read into main memory, block b ₃ is common block next, so that the processing of the task t ₆ ^4, t ₁ ⁴ in a common block b _3. When the processing of the task in the block b ₃ which is the common block is completed, it is not necessary to access the block b ₃ again, so that the set B ₆ ^{4 (1)} , B ₁₄ ⁽¹⁾ and the set {b ₃ } Find the difference set. Assuming that the values of the obtained difference sets are B ₆ ^{4 (2)} and B ₁₄ ⁽²⁾ , the following is obtained.
For task t ₆ ⁴ : B ₆ ^{4 (1)} − {b ₃ } = {} = B ₆ ^{4 (2)}
For task t ₁ ⁴ : B ₁ ^{4 (1)} − {b ₃ } = {b ₁ } = B ₁ ^{4 (2)}

As a result, it can be seen that the set B ₆ ^{4 (3)} the processing of the task t ₆ ⁴ empty set {} is completed. At this stage, since the remaining tasks in the group and only the t ₁ ^4, performs processing tasks t ₁ ⁴ accesses the block b ₁ remaining from relation TEMP_SG1_G1, in the group when the processing of the task t ₁ ⁴ ends All tasks will be processed.

As described above, the blocks in the relation TEMP_SG1_G1 b _4, by b _2, b _3, are accessed in the order of b _1, a small task of processing cost t ₃ at ^{_{3, t 6 4, t 1}} 4 order It can be seen that the task processing ends. FIG. 10 shows a state in which processing of the group G6 is performed using static multi-operation processing. Process (801) is a relation TEMP_SG1_G1 (800) in the block access in the order of _{b 4, b 2, b 3} , b 1, performs processing tasks ^{_{t 3 3, t 6 4,}} t 1 4 at a time The processing results are written in TEMP_T3_3, TEMP_T4_6, and TEMP_T4_1.

[(F-6) Create new group]
Task multi-operation processing group G6 using is, upon completion in the order of the task _{^{t 3 3, t 6 4,}} t 1 4, starting from the process tree of Figure 4-1 Figure 4-3 topological sort You will find a task that can be newly processed.
First, when the processing of task t ₃ ³ is completed, the processing of task t ₃ ⁴ can be newly started as can be seen from the processing tree P ₃ . Task t ₃ ⁴ is a task that performs a join operation using the processing result TEMP_T1_3 of task t ₃ ^{1 and} the processing result TEMP_T3_3 of task t ₃ ³ , and uses TEMP_T1_3 as the relation of the search destination and TEMP_T3_3 as the search source it means to use as a relation, creates a new group G12 added task t ₃ ⁴ group G12 and as a task that performs processing on TEMP_T3_3 a search source relation.

Next, when the processing of task t ₆ ⁴ is completed, as can be seen from the processing tree P ₆ , the processing of task t ₆ ² in group G7 has not been completed. No groups are created.
Finally, when the processing of the task t ₁ ⁴ is completed, the new group since the processing of the task t ₁ ² has not been completed in the group G8 As can be seen from the process tree P ₁ is not created.
In summary, will add the task t ₃ ⁴ found by the processing of the task ^{_{t 3 3, t 6 4,}} t 1 4 in the group G6 is terminated group G12 as follows .
TEMP_T3_3: Group G12 = {t ₃ ⁴ }
(t ₃ ⁴ ): TEMP_T4_3 ← TEMP_T1_3 | X | _{DNUMBER = DNUM} TEMP_T3_3

  In this way, as the group processing is repeated, the tasks in the processing tree shown in FIGS. 4-1 to 4-3 are gradually completed, and all the tasks in the processing tree are processed. When finished, all query processing given will end.

[3. Actual processing result]
A query processor using multi-operation processing using a composition relational operation can process a larger number of queries faster than a query processor using multi-operation processing and a conventional query processor (MySQL Ver.3). In order to prove the above, a function capable of performing multi-operation processing using synthetic relational operations is newly added to the MOB-DB of the database management system (DBMS) developed independently. MOB-DB aims to process many queries at a higher speed than database systems widely used in the market such as MySQL, SQL interpreter, query optimization, simultaneous processing of transactions, storage for storing data This software has sufficient functions necessary for a database management system (DBMS) such as a system. In conducting multi-operation processing experiments using composition-related operations, we decided to use static multi-operation processing for multi-operation processing using composition-related operations.

By adding query processing using static multi-operation processing using synthetic relational operations to MOB-DB developed uniquely, MOB-DB uses query multi-operations using synthetic relational operations, Query processing using static multi-operation processing and query processing using dynamic multi-operation processing can be performed, and these query processing methods can be freely selected and executed.
Next, using MOB-DB, the query processing speed by these query processing methods was examined. Furthermore, in order to compare with version 3 of MySQL widely used in the market, common query processing was performed to examine the processing speed of MOB-DB and MySQL.

  In order to test query processing using MOB-DB, a sufficiently large database that stores a large number of records is required. Therefore, a general entry level personal computer (one Celeron equipped with Windows XP Professional (R)) is installed. Create a database consisting of 4 relations (relationship EMPLOYEE, DEPARTMENT, WORKS_ON, PROJECT in Fig. 11) on a CPU 2.53GHz processor, 512MB main memory, and one 145GB disk), and record 100,000 records for each relation. And a total of 400,000 records were added to the database. In order to process the query efficiently and quickly, an index is required for the relation, so a primary index (1100) is created for the primary attribute SSN of the relation EMPLOYEE (1101) and a secondary is set for the secondary attribute PHONE. An index (1102) was created. In relation DEPARTMENT (1105), a primary index (1104) is created for the primary attribute DNUMBER, and a secondary index (1106) is created for the secondary attribute DPHONE. In relation PROJECT (1108), a primary index (1107) is created for the primary attribute PNUMBER. Similarly, when using MySQL version 3, a common database composed of four relations was created, and an index was added to the relations in the database in the same manner as MOB-DB.

  Next, the queries that query the database server described many different queries in SQL that require complex search processing to make the best use of the processing power of each query processor. These queries have the following conditions and characteristics.

(1) In order to prevent the same query from being included as one query, the search conditions for all queries are different. Each query is combined with Boolean AND and OR search conditions consisting of operations, attributes, and variables, and a narrow search is performed with more complicated search conditions.

(2) Each query includes two or more join operations so that the query processor can perform sufficient join operation processing. Each query is given a search condition that does not become zero so that the query processor can always obtain a search result.

(3) Queries that obtain 1000 or less processing results, queries that obtain 1000 to 10,000 processing results, and 10,000 to 50,000 so that all kinds of processing results can be obtained by the query processor A sufficient number of queries (25 percent each) were queried from the database for queries from which 50,000 to 100,000 results were obtained.

(4) A query that uses a primary index as a search condition, a query that uses a secondary index, and a query that uses both a primary index and a secondary index are provided so that a search using an index is performed by a query processor. It was. In addition, a query that does not use both the primary index and the secondary index is given as a selection condition so that a query that does not use an index is processed along with a query that uses an index.

  Query processing using static multi-operation processing using MOB-DB composition-related operations, query processing using dynamic multi-operation processing, query processing using static multi-operation processing, and processing speed of MySQL version 3 In order to check the database, a client program that requests the database server to search is prepared, the client program queries the database server for a number of queries written in SQL, and all queries are processed by the query processor on the database server. Then, a method of measuring the time until the search result is returned to the client program is used. In order to avoid the influence of the communication speed between the client computer and the database server, the client program was started directly on the database server to obtain the search processing result. Gradually increase the number of queries created to query the database to 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 The query processing speed was measured in increments. Similarly, for MySQL version 3, using the same number of queries as the number of cases described above, the processing speed of the MySQL query is measured, and the processing speed of MySQL and the composite relational operation using MOB-DB are used. The processing speed was compared with static multi-operation processing, dynamic multi-operation processing, and static multi-operation processing.

  FIG. 12 shows a case where a large number of queries are made to version 3 of static multi-operation processing, dynamic multi-operation processing, static multi-operation processing, and MySQL using a composition relation operation of MOB-DB. The results of comparing the relationship between the number of queries and the query processing speed are shown in a table (see FIG. 12A) and a graph (see FIG. 12B).

  From the processing results shown in FIGS. 12 (a) and 12 (b), static multi-operation processing using synthetic relational operations is the fastest overall in the number of queries from 100 to 1000, It can be seen that the processing speed of dynamic multi-operation processing is fast, followed by static operation processing, and the processing speed of MySQL is the slowest.

  In static multi-operation processing using synthetic relational operations, the average number of queries from 100 to 500 is 1.64 times faster than dynamic multi-operation processing, which is higher than static multi-operation processing. 1.76 times faster on average, 6.34 times faster on average than MySQL version 3, with 600 to 1000 queries compared to dynamic multi-operation processing 1.65 times faster on average, 1.79 times faster than static multi-operation processing, and 6.47 times faster on average than MySQL version 3 It was.

  As described above, static multi-operation processing using composition-related operations has an improved processing speed compared to these query processors, and an improvement in processing speed of 6.34 to 6.47 times that of MySQL version 3 can be seen. As the number increases, the processing speed tends to improve.

It is a figure which shows the structural example of the architecture of a database system. It is a flowchart which processes a query. It is a figure which shows the relation DEPARTMENT of the database used by embodiment. It is a figure which shows relation EMPLOYEE of the database used by embodiment. It is a figure which shows relations PROJECT and WORKS_ON of the database used by embodiment. It is a diagram showing a processing tree P _1. Processing tree P _2, P _3, is a diagram illustrating a P _4. It is a diagram showing a processing tree P _5, P _6. It is a figure explaining grouping and subgrouping of a task. It is a figure explaining the optimization of a synthetic | combination selection calculation. It is a figure explaining static multi operation processing using composition relational operation. It is a figure explaining the procedure for sharing the process result of a synthetic | combination selection calculation. It is a figure explaining the procedure (continuation) for sharing the process result of a synthetic | combination selection calculation. It is a figure explaining static multi operation processing using composition relational operation. It is a figure explaining the static multi-operation processing with respect to the relation obtained as a process result of a synthetic | combination relational calculation task. It is a figure which shows the relation of the database which processed actually. It is a figure which shows a processing result.

Claims (7)

A database query processing system using multi-operation processing using composition relational operations,
Processing tree conversion means for converting the query into a processing tree based on a relational algebra;
From the processing tree, by means of topological sorting, task retrieval means for retrieving as a task in an order in which relational algebra can be implemented without depending on the result of other relational algebra;
A grouping means for grouping the retrieved tasks for each relation of the database;
For the tasks divided into groups, a task having a common sub-expression is further collected into subgroups, and a composite relational calculation creating means for creating a composite relational calculation task;
Multi-operation processing means for performing multi-operation processing on the created synthetic relational calculation task and a task that does not gather in a subgroup for each grouped task;
Stores relations obtained as a result of processing of the composite relation calculation task in the group so that individual tasks included in the composite relation calculation partially share the relation records and / or attributes. A query processing system comprising: a virtual relation creating means for creating a virtual relation by position. The query processing system according to claim 1.
The composite relational operation creation means is configured such that when the attribute names and the number of attributes used in the plurality of selection calculation tasks collected in the subgroup are equal, only a selection condition related to one attribute among the attributes is different or If the selection conditions for the other attributes are exactly the same, connect those selection conditions using a Boolean OR and remove the duplicated selection from the connected selection conditions In addition, a query processing system is characterized in that a selection condition that is simplified and optimized is created, and a composite relation operation of a plurality of selection operation tasks is created using the selection condition. The query processing system according to claim 1.
If the plurality of projection calculation tasks collected in the subgroup perform the projection calculation processing on the common relation, the composite relation calculation creation means can obtain the union of the attributes of these projection calculation tasks. A query processing system characterized by creating a composition relation operation of a plurality of projective operation tasks using the determined attributes. In the query processing system according to any one of claims 1 to 3,
The virtual relation creating means creates an index for an attribute used for searching a relation partially shared by the virtual relation when the task performs a search process on the record of the virtual relation. Query processing system. In the query processing system according to any one of claims 1 to 4,
The query processing system according to claim 1, wherein the grouping means groups the tasks for each relation obtained as a result of processing the synthetic relational calculation task.   A program for causing a computer system to realize each function of a database query processing system using multi-operation processing using a composition relational operation according to any one of claims 1 to 5.   A recording medium storing a program for causing a computer system to realize each function of the database query processing system using multi-operation processing according to claim 1.