JPH0581334A - Data base arithmetic processor - Google Patents

Abstract

PURPOSE:To shorten the time until a processing of quasi-coupling or coupling of an object table is started after read-in of a condition table is started. CONSTITUTION:A first and a second input processing threads, and a thread for requesting a processing to an ECAN (hardware sorter control processor) having a parallel sorting module and a parallel relation algebra arithmetic module are generated successively (S12-S14), a condition table from a disk device is read in immediately by a first input processing thread, data of the read-in condition table is loaded to the ECAM by an ECAM processing request thread, and after a loading end notice from the request thread (S15), an input start is requested to a second input processing thread and the input of an object table from the disk device is started (S16), and a quasi-couplinr or coupling processing is executed by the ECAM.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a database operation processing device for receiving a database operation command given from a host device and executing a specified operation process, and more particularly to a semi-join process which is a relational database operation from the host device. Further, the present invention relates to a database operation processing device that performs input from a secondary storage device of a condition table and a target table and semi-join or join in parallel in response to a request for join processing.

[0002]

2. Description of the Related Art In a conventional database operation processing device that receives a database operation command given from a host device and executes a specified operation process, a relational database operation is a semi-join process (RESTRICT) or join process (JO).
IN) request, 2 of condition table and target table
Reading from the next storage device, for example, a disk (disk device) was started at the same time. When both tables have been read, the condition table is loaded,
Processing of the target table was started after loading was completed.

[0003]

As described above, in the conventional database arithmetic processing device, in response to the request of the semi-join process or the join process, the condition table and the target table are divided into two.
Reading from the next storage was started at the same time. In this method, since the reading of both tables is performed in parallel, the amount of reading of each table per unit time is about half that when reading alone. That is, in the conventional database arithmetic processing device, since the condition table and the target table are read in parallel, it takes time to read both tables, and thus it takes time to complete the loading of the condition table. As a result, there is a problem that it takes time to start processing the target table. In particular, this problem was remarkable when the size of the condition table was not smaller than the size of the target table.

The present invention has been made in view of the above circumstances, and an object thereof is to reduce the time from the start of reading a condition table to the start of semi-join or join processing of target tables, and thus semi-join. An object of the present invention is to provide a database arithmetic processing device capable of speeding up processing and joining processing.

[0005]

SUMMARY OF THE INVENTION The present invention is connected to a host device and a secondary storage device for storing table data to be operated and stores the table data to be operated in response to a command given from the host device. In a database operation processing device that inputs and executes predetermined database operation processing, interface control between the first processor that controls the entire device and the host device, and input / output control between the secondary storage device are performed. A second processor, a parallel sorting mechanism for executing sorts in parallel, and a parallel relational algebra operation mechanism for executing various relational algebraic operations in parallel are added, and these two mechanisms are controlled in response to a request from the first processor. And a first input buffer and a second input buffer for temporarily storing table data to be operated. And an internal memory, the first
The processor of causes the second processor to read the condition table data designated in the first input buffer from the secondary storage device by the second processor when a command for instructing the semi-join or the join is given from the host device. The condition table data read into the first input buffer is loaded into the same processor as the batch processable amount in the third processor, and then the second processor loads the secondary storage device to the second input buffer. It is characterized in that the designated target table data is read and the semi-join or join processing is performed by the third processor.

[0006]

In the above configuration, since the condition table is read in advance and the target table is started to be read after this condition table is completely loaded, the condition table can be read in a short time. The time from the start of reading the condition table to the start of the semi-join or join processing of the target table can be shortened.

[0007]

Embodiments of the present invention will be described below with reference to the drawings.

FIG. 1 shows the overall system configuration of a data processing apparatus according to an embodiment of the present invention. This data processing device includes a host computer 10 and a database arithmetic processing device (database engine; DBE).
16 and a disk device 17 such as a magnetic disk device. The host computer 10 is C
The CPU 11 includes a PU 11, a main memory device 12, and first and second channel devices 14 and 15.
1, the main storage device 12 and the channel devices 14 and 15 are interconnected via a system bus 13.

The host computer 10 and the database arithmetic processing unit (DBE) 16 are connected by a channel device 14, and the host computer 10 and the disk device 17 are connected by a channel device 15. Further, the database operation processing device (DBE) 16 and the disk device 17 are connected via a dedicated path 18.

The CPU 11 controls the host computer 10 as a whole, and requests the database arithmetic processing unit (DBE) 16 to execute various arithmetic processes such as sorting and relational algebraic arithmetic. In the main storage device 12,
A command group for instructing a calculation target file and calculation contents to the database calculation processing device (DBE) 16 is stored.

Database arithmetic processing unit (DBE) 16
Is for executing arithmetic processing on the data of the calculation target file based on a command from the CPU 11,
To input the calculation target file and output the calculation result,
The disk device 17 is directly accessed via the path 18.

This DBE (database arithmetic processing unit)
16 is an engine interface processor (EI
P) 161, engine control processor (ECP) 16
2. A large capacity memory (EBDM) 163, a hardware (HW) sorter control processor (ECAM) 164, a parallel sorting module (PSOM) 165, and a parallel relational algebra operation module (PRAM) 166.

An EIP (engine interface processor) 161, an ECP (engine control processor) 16
2 and ECAM (hardware sorter control processor)
The three processors 164 are interconnected by an internal bus 167, and an EBDM (large capacity memory) 163.
Tightly coupled multi-processor with shared memory is configured. The EBDM 163 is arranged in a common address space of each of the three processors. Further, the functions are distributed to these three processors, that is, the EIP 161, the ECP 162, and the ECAM 164. In this case, in order to efficiently carry out each unique role,
Each of these processors is configured to be tightly coupled and controlled by an independent monitor suitable for each processor.

EIP 161, ECP 162 and ECAM
The function distribution of 164 is performed as follows.

That is, the EIP (engine control processor) 161 communicates between the host computer 10 and the DBE 16 and is also connected to the disk controller of the disk device 17 via the path 18 to exchange data with the disk device 17. Control I / O. Also, EI
When P161 outputs data to the disk device 17,
It also reconstructs the output file.

In the communication with the host computer 10, the EIP 161 receives the command sent from the CPU 11 via the first channel device 14 and sends it to the ECP 162. Also, the EIP 161 is
The status as the command result sent from the ECP 162 is received and returned to the CPU 11 via the first channel device 14.

In the data input / output processing with the disk device 17, the EIP 161 receives the input / output request from the ECP 162 and directly transfers the data between the EBDM 163 and the disk device 17.

The ECP 162 is an EIP 161, an EBDM
163 and ECAM 164 are controlled via internal bus 167 to perform data processing.

The EBDM (large-capacity memory) 163 is a file data (table data) to be operated, which is read from the disk device 17, ECAM 164, PSOM 16
5 and the PRAM 166 is a shared memory for storing sort processing results, relational algebraic operation results, and the like.

The ECAM (hardware sorter control processor) 164, based on the command from the ECP 162,
The operation by the PSOM 165 and the PRAM 166 is controlled.

In this case, the ECAM 164 is the EBDM1
The data on 63 is input to PSOM165, and PRAM1
The calculation result output from 66 is stored in the EBDM 163, but when data is input to the PSOM 165, key cutout processing is executed. In this key cutout processing, the ECAM 164 cuts out only the key necessary for the calculation from each record to be calculated, adds the record identification number RID (the start address of the record on the EBDM 163) to the key and sends it to the PSOM 165.

PSOM (parallel sorting module)
165 is a dedicated hardware circuit that is driven by the ECAM 164 and executes sorting in parallel.
It is connected to M166. The PSOM 165 is called a pipeline merge sorter, and is composed of a plurality of sort cells cascade-connected to perform 2-way merge.

PRAM (parallel relational algebra operation module)
166 is JOIN (join) in relational database
This is a dedicated hardware circuit that executes relational algebraic operations such as RESTRICT (constraints, semi-joins) in parallel.
Input the sorted data from 65 and EC the calculation result
Output to AM164. When only the sorting process is executed, the PRAM 166 functions as the final sort cell.

FIG. 2 shows the CPU of the host computer 10 (
11 shows a command sequence 21 given to DBE (database arithmetic processing unit) 16 from 11). This command sequence 21
Is composed of a command group (commands # 1, # 2 ... #n) representing a series of processing contents to cause the DBE 16 to perform processing from the host computer 10 and the number of commands in the command sequence.

As the command, READ for instructing the reading of the table from the disk device 17 to the EBDM 163
Command, PROJECTION command for instructing to output the data on the EBDM 163 to the disk device 17 or the EBDM 163 in the specified format, and RESTRI
CT command is prepared. This RESTRICT command is a command to instruct to perform constraint (semi-join) with columns of different tables as conditions, that is, to compare multiple columns of the target table and condition table and select records in the corresponding target table. is there.

As a command, SELECT for instructing selection by columns or constants of the same table
After selecting records according to the condition for the given column for each of the command, target table and condition table, compare the selected record group of the target table and multiple columns of the selected record group of the condition table SELSEL JOIN command (a type of JOIN command that performs a join by the specified key column) for instructing to select the record in the target table to be processed, and WORKFILE for specifying the work file on the disk device 17
Commands are also prepared.

Each command constituting the command sequence 21 is
As shown in the figure, it comprises a command code and various information necessary for processing in the DBE 16. This information is, for example, RESTRI
In the case of the CT command, the table to be selected, the table to be the condition, the column of the target table, the column of the condition table, the comparison operator, and the like. Also, SELSEL
If it is a JOIN command, the table to be joined and
The table that is a condition, the selection condition for the target table, the selection condition for the condition table, the column of the target table, the column of the condition table, the operator for joining, and the like.

FIG. 3 shows the processing status 23 sent from the DBE 16 to the host computer 10. The processing status 23 is for notifying the computer 10 of the processing result of the command group received the processing request from the host computer 10.

FIG. 4 shows the structures of the condition table 24a and the target table 24b. The condition table 24a is the target of command processing, and may be placed in the disk device 17 or read and placed in the EBDM 163. On the other hand, the target table 24b is the target of command processing, and may be placed in the disk device 17 or read and placed in the EBDM 163.

FIG. 5 shows the structures of the input buffers 25a and 25b and the output buffer 26 secured in the EBDM 163. The condition table 24a shown in FIG. 4 is read from the disk device 17 and stored in the EBDM 163 in the input buffer 25a. The target table 24b shown in FIG. 4 is stored in the input buffer 25 from the disk device 17 to the EBDM1.
It is read and stored in 63. Input buffer 25a,
25b is used by dividing it into unit buffers (input unit buffers) of a fixed size. The size of the input unit buffer is set so that the EIP 161 has a data amount with which data can be most efficiently input from the disk device 17.

The output buffer 26 is the ECAM 164.
For holding the processing result of. The output buffer 26 is used by being divided into unit buffers (output unit buffers) corresponding to the unit buffers (input unit buffers) of the input buffers 25a and 25b. In the present embodiment, the processing result of the ECAM 164 stored in the output buffer 26 is represented by RID (pair). Therefore, the output unit buffer of the output buffer 26 is the input buffer 2
The size is smaller than the input unit buffer of 5a and 25b.

FIG. 6 shows the functional configuration of the ECP (engine control processor) 162 of FIG. 1 by the interrelationship of various tasks (hereinafter referred to as threads) generated by the ECP 162.

In the figure, reference numeral 29 is a command analysis thread, which is a thread (command processing) for analyzing the command sequence 21 from the host computer 10 in order from the first command and processing the corresponding command for each analysis. (Thread), and sends the result as a processing status 23 to the host computer 10.

Reference numeral 30 is one of the command processing threads successively generated by the command analysis thread 29. The processing method is determined from the utilization status of the hardware resources in the DBE 16, and the input processing thread 31a, if necessary.
Input processing thread 31b, ECAM processing request thread 3
2 is generated, and after the command processing is completed, the processing result is transmitted to the command analysis thread 29. A command processing thread generated one after another by the command analysis thread 29 analyzing the command sequence 21 has a command processing thread generated prior to the command processing thread 29. If there is a command processing thread generated earlier than that, the own thread can process the thread. Processing will start as soon as. As a result, the command processing threads can operate in parallel.

Reference numeral 31a is an input processing thread, which inputs the processing target table 27a on the disk device 17 to the input buffer 25a. Reference numeral 31b is an input processing thread, which inputs the processing target table 27b on the disk device 17 to the input buffer 25b. Reference numeral 32 is an ECAM processing request thread, which is the input buffer 27a.
Data (including the input buffer 27b in the case of 2-input commands such as RESTRICT command and SELSELJOIN command)
It passes the data to the CAM 164, requests the processing, and sends the processing result to the command processing thread 30.

Next, the DB in the data processor of FIG.
The operation of E (database arithmetic processing unit) 16
A case where the CT command and the SELSEL JOIN command are executed and the entire table to be processed can be processed by the ECAM 164 at one time will be described as an example with reference to the flowcharts of FIGS. 7 to 11 as appropriate. Note that FIG. 7 shows ECP16.
2 is a flowchart showing the processing procedure of the command analysis thread 29 in FIG. 2, and FIG. 8 is a flowchart showing the processing procedure of the command processing thread 30 in the ECP 162. 9 is a flowchart showing the processing procedure of the input processing thread 31a in the ECP 162, and FIG.
FIG. 11 is a flowchart showing the processing procedure of the input processing thread 31b in the CP 162, and FIG. 11 is a flowchart showing the processing procedure of the ECAM processing request thread 32 in the ECP 162.

In the following, it is assumed that the condition table 24a and the target table 24b are on the disk device 17.

First, (the CPU of the host computer 10
When the command sequence 21 shown in FIG. 2 is sent from 11) to the DBE 16 via the system bus 13 and the first channel device 14, the command sequence 21 is received by the EIP 161 and passed to the ECP 162. As a result, ECP
The command analysis thread 29 is generated by 162.

The command analysis thread 29 (the ECP 162 which operates in accordance with the command) receives the command string 21 from the host computer 10 (step S1 in FIG. 7), knows the command number n by looking at the head of the command string, and continues until there are no more commands. When the command code in 21 is read, the generation of the command processing thread that performs the processing for the command code is repeated (step S2 in FIG. 7).
S3). At that time, the corresponding command is passed to the command processing thread. The command analysis thread 29 generates command processing threads for all the commands in the command sequence 21, and then sequentially receives processing result messages from each thread (step S4 in FIG. 7), and the processing results of all commands are complete. After that, the results are put together and the processing result status 2 is sent to the host computer 10 via the EIP 161.
3 is transmitted (step 5 in FIG. 7).

Here, it is assumed that the command is the RESTRICT command or the SELSEL JOIN command, and the command processing thread 30 is generated corresponding to the command.

The command processing thread 30 (the ECP 162 which operates according to the command processing thread) receives the command (RESTRICT command or SELSELJO) received from the command analysis thread 29.
IN command) based on various information for command processing,
Process the command. First, the command processing thread 3
0 determines the processing based on the command and the usage status of the DBE 16 (step S11 in FIG. 8). In step S11, the command processing thread 30 analyzes the commands and calculates whether the ECAM 164 can perform batch processing.
Acquisition of output buffer 26, acquisition of input buffer 25a,
It also acquires the input buffer 25b.

Next, the command processing thread 30 inputs the condition table 24a into the input buffer 25a, the input processing thread 31a, and the target table 24b into the input buffer 2.
Input processing thread 31b read into 5b and ECAM
A thread (ECAM processing request thread) 32 for requesting processing to 164 is generated (steps S12 to S1 in FIG. 8).
4). Then, the command processing thread 30 waits for the load end message from the ECAM processing request thread 32, and then transmits a message requesting the start of reading to the input processing thread 31b that reads the target table 24b (steps S15 and S16 in FIG. 8). ). afterwards,
The command processing thread 30 receives the processing end message from each thread (here, the input processing threads 31a and 31b and the ECAM processing request thread 32), and sends the results together to the command analysis thread 29 (FIG. 8, step S17, S18).

On the other hand, the input processing thread 31a (the ECP 162 operating in accordance therewith) starts the input processing operation shown in the flowchart of FIG. 9 immediately after the thread 31a is generated, and the first unit buffer of the input buffer 25a receives the input. If it is possible, the EIP 161 is requested to input the condition table 24a (steps S21 to S in FIG. 9).
23). As a result, the EIP 161 becomes the disk device 17
From the above, the condition table 24a is input via the path 18 for the first unit buffer, and is written in the first unit buffer of the input buffer 25a. In this way, the input (for the unit buffer of the condition table 24a) to the first unit buffer of the input buffer 25a is completed.

The input processing thread 31a repeats the same operation for the second and subsequent unit buffers until all the condition tables 24a have been read. When the input processing thread 31a finishes reading the condition table 24a and determines that the reading is completed, the input processing thread 31a notifies the command processing thread 30 of the processing result (FIG. 9, steps S24, S).
25).

On the other hand, the input processing thread 31b is
Until the reading start message is received from the command processing thread 30, that is, the reading of the condition table 24a into the input buffer 25a by the input processing thread 31a is completed, and further the ECAM 164 of the condition table 24a read into the input buffer 25a ( Input processing is kept waiting until the load (for batch processing) is completed.

When a read start message is received from the command processing thread 30 in the end, the input processing thread 31b (the ECP 162 operating in accordance with it) determines that the input table in the input buffer 25b is ready for input to the target table in the EIP 161. The input processing of 24b is requested (steps S31 to S33 in FIG. 10). As a result, the EIP 161 inputs the target table 24b from the disk device 17 for the first unit buffer via the path 18 and writes the target table 24b in the first unit buffer of the input buffer 25b. In this way, the input (for the unit buffer of the target table 24b) to the first unit buffer of the input buffer 25b is completed.

The input processing thread 31b repeats the same operation for the second and subsequent unit buffers until the target table 24b is completely read. Then, when the input processing thread 31b finishes reading the target table 24b and determines the fact, it notifies the command processing thread 30 of the processing result (FIG. 10, step S34,
S35).

Now, the ECAM processing request thread 32 (the ECP 162 which operates according to the ECAM processing request thread) 32 is operated by the input buffer 25a.
When the unit buffer in the unit can be loaded, the contents of the unit buffer (the unit buffer data of the condition table 24a) are sequentially loaded into the ECAM 164 (FIG. 11).
Steps S41 to S43) are repeated. In this load operation, the condition keys are sorted by the PSOM 165 of the ECAM 164 and stored in the buffer (not shown) of the PRAM 166. In the case of the SELSELJOIN command, the ECAM16 is used before the sorting by the PSOM165.
At 4, a column or constant selection is made.

The ECAM processing request thread 32 uses the ECA
When the loading of the amount of data (the data of the condition table 24a) that can be collectively processed in M164 is completed, a load end message is transmitted to the command processing thread 30 (steps S44 and S45 in FIG. 11).

As described above, in this embodiment, the condition table 2
4a from the disk device 17 and the process of loading the input condition table 24a into the ECAM 164 are performed in parallel.

Next, the ECAM processing request thread 32 requests the ECAM 164 to process the data of the unit buffer (data of the target table 24b) in the input buffer 25b which can be processed by the input processing of the input processing thread 31b. The result is output to each unit buffer of the output buffer 26 (step S46 in FIG. 11). As a result, the ECAM 164 controls the PSOM 165 and the PRAM 166 for the data of the previously loaded condition table 24a and the input data of the target table 24b, and specifies the specified command (RESTRICT command or SELS
ELJOIN command) processing (semi-join or join processing) is performed, and the result is written in each unit buffer of the output buffer 26. For example, if it is a SELSEL JOIN command, ECA
The target key input to M164 and sorted by PSOM165 is combined with the condition key already stored in the buffer of PRAM166, and the result is output to the output buffer 26 as a pair of the record identification number RID of the corresponding record. Written in.

As described above, in this embodiment, the target table 2
4b input from the disk device 17 and ECAM
The semi-join or join processing at 164 is performed in parallel.

The ECAM processing request thread 32 transmits the processing result to the command processing thread 30 after the processing in step S46 is completed (step S47 in FIG. 11).

As described above, in the present embodiment, the internal bus 16
EIPs interconnected by 7 and capable of operating in parallel with each other
(Engine Interface Processor) 161, ECP
(Engine control processor) 162 and ECAM (hardware sorter control processor) 164, and EBD shared by these processors
M (large capacity memory) 163 and PSOM (parallel sorting module) 1 controlled by ECAM 164.
65 and PRAM (parallel relational algebra operation module) 16
6 and DBE (database arithmetic processing unit) 16
Are configured.

In this embodiment, the host computer 1
RESTRICT command or SELSEL JOIN from 0 to DBE16
When a command string 21 including a command is sent, EC
The command analysis thread 29 is generated in P162. The command analysis thread 29 generates command processing threads represented by a command processing thread 30 that analyzes the command string 21 and processes each command in the command string 21 one after another, and receives processing results from them. The processing status 23 is collectively notified to the host computer 10.

The command processing thread 30 is composed of the input processing threads 31a and 31b and the ECAM processing request thread 3.
2 are sequentially generated, and after the load end message is received from the ECAM processing request thread 32, the input processing thread 3
The input start message is transmitted to 1b, and the command processing result is transmitted to the command analysis thread 29 based on the processing message from each thread.

The input processing thread 31a immediately transfers the condition table 24a from the disk device 17 to the input buffer 25.
The input processing thread 31b inputs the target table 24b from the command processing thread 30 after receiving the read start message from the disk device 17 after the processing is completed. It is configured to read into the buffer 25b and send the processing result after the processing is completed to the command processing thread 30.

The ECAM processing request thread 32 uses the unit buffer in the input buffer 25a which has become processable as E.
Sequential loading to the CAM 164, and after the ECAM 164 has completed loading of the batch processable amount, a load end message is sent to the command processing thread 30, and the unit buffer in the input buffer 25b that has become processable is set to ECAM1.
It is configured to request 64 to process and output to each unit buffer of the output buffer 26, and to transmit the processing result to the command processing thread 30.

With this arrangement, the condition table 24
a from the disk device 17 to the input buffer 25a in advance, and the input buffer 25a to the ECAM 16
No. 4 to the input buffer 25b after the loading of the condition table 24a into the target table 24b is completed.
Can be started, and therefore the reading time of the condition table 24a can be shortened (almost half of the conventional time), and the reading of the condition table 24a can be started before the semi-join or join processing of the target table 24b. It can shorten the time until.

[0060]

As described in detail above, according to the present invention,
Since the condition table is read in advance and the target table is read after this condition table is completely loaded, the condition table can be read in a short time, and the condition table can be read. The time from the start of processing the semi-join or the join of the target tables can be halved compared to the conventional method in which the condition table and the target table are read in parallel.
The speed of the semi-join process and the join process can be increased. This effect is
This is particularly noticeable when the size of the condition table is not smaller than the size of the target table.

[Brief description of drawings]

FIG. 1 is a block diagram showing a system configuration of a data processing device according to an embodiment of the present invention.

FIG. 2 is a diagram showing a configuration of a command sequence given from a host computer 10 in FIG. 1 to a database arithmetic processing unit (DBE) 16.

FIG. 3 is a diagram showing a configuration of a processing status sent from a database arithmetic processing unit (DBE) 16 to a host computer 10.

FIG. 4 is a diagram showing structures of a condition table and a target table.

5 is an input buffer 25a, 25b and an output buffer 2 secured in a large capacity memory (EBDM) 163 of FIG.
The figure which shows the structure of 6.

6 is an engine control processor (ECP) 16 of FIG.
The figure which shows the 2nd function structure by the mutual relationship of the various threads produced | generated by the same processor 162.

7 is a flowchart showing a processing procedure of a command analysis thread 29 of FIG.

8 is a flowchart showing a processing procedure of a command processing thread 30 of FIG.

9 is a flowchart showing a processing procedure of an input processing thread 31a shown in FIG.

10 is a flowchart showing a processing procedure of an input processing thread 31b shown in FIG.

11 is a flowchart showing a processing procedure of an ECAM processing request thread 32 of FIG.

[Explanation of symbols]

10 ... Host computer, 11 ... CPU, 16 ... Database arithmetic processing unit (DBE), 17 ... Disk device (secondary storage device), 18 ... Path, 161, ... Engine interface processor (EIP, second processor),
162 ... Engine control processor (ECP, first processor), 163 ... Large-capacity memory (EBDM, internal memory), 164 ... Hardware (HW) sorter control processor (ECAM, third processor), 165 ... Parallel sorting module (PSOM), 166 ... Parallel algebraic arithmetic module (PRAM), 21 ... Command sequence,
23 ... Processing status, 24a ... Condition table, 24b
... Target table, 25a ... Input buffer (first input buffer), 25b ... Input buffer (second input buffer), 26 ... Output buffer, 29 ... Command analysis thread, 30 ... Command processing thread, 31a ... Input processing thread (First input processing task), 31b ... Input processing thread (second input processing task), 32 ... ECAM processing request thread (interface processing task).

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Takao Iwasaki 2-9 Suehiro-cho, Ome-shi, Tokyo Stock company Toshiba Ome factory (72) Inventor Hiroka Yamada 2-9 Suehiro-cho, Ome-shi, Tokyo Shareholders Inside the Toshiba Ome Plant (72) Inventor Kazunori Shimakawa 2-9 Suehiro-cho, Ome-shi, Tokyo Stock Company Inside the Toshiba Ome Plant (72) Inventor Yuji Sato 1385 Shinmachi, Ome-shi, Tokyo Inside Toshiba Software Engineering Co., Ltd. (72) Inventor Hiroki Soto 1385 Shinmachi, Ome-shi, Tokyo Within Toshiba Soft Engineering Co., Ltd. (72) Inventor Shinichi Amano 1385 Shinmachi, Ome-shi, Tokyo Inside Toshiba Soft Engineering Co., Ltd.

Claims (3)

[Claims] 1. A predetermined database operation, which is connected to a host device and a secondary storage device for storing table data to be operated, and inputs the table data to be operated in response to a command given from the host device. In a database arithmetic processing device that executes a process, an interface control between a first processor that controls the entire device and the host device, and
A second processor that controls input / output to and from a next storage device, a parallel sorting mechanism that executes sorts in parallel, and a parallel relational algebra operation mechanism that executes various relational algebraic operations in parallel are added, and the first processor is added. A third processor for controlling both mechanisms in response to a request from the processor; and an internal memory in which first and second input buffers for temporarily storing table data to be operated are provided. The first processor operates from the host device to the second device.
Condition given by the second processor from the secondary storage device to the first input buffer of the internal memory when a command for instructing quasi-joining or joining is given through the processor The table data is read, and at the same time, the condition table data read in the first input buffer is loaded into the same processor in an amount that can be collectively processed by the third processor,
The second processor causes the second input buffer of the internal memory to read the target table data specified by the command from the secondary storage device, and the third processor
Database arithmetic processing device, characterized in that it is configured to perform a quasi-joining or joining process in the processor. 2. A predetermined database operation, which is connected to a host device and a secondary storage device for storing table data to be operated, and inputs the table data to be operated in response to a command given from the host device. In a database arithmetic processing device that executes a process, an interface control between a first processor that controls the entire device and the host device, and
A second processor that controls input / output to and from the next storage device, a parallel sorting mechanism that executes sorts in parallel, and a parallel relational algebra operation mechanism that executes various relational algebraic operations in parallel are added, and the first processor is added. A third processor for controlling both mechanisms in response to a request from the processor; and an internal memory in which first and second input buffers for temporarily storing table data to be operated are provided. The first processor is a command processing task for processing a command given from the host device, and among the processing required to execute the command under the control of the command processing task, An input / output processing task that controls the input / output processing related to the second processor and an interface processing task that controls the interface with the third processor. Click to generate necessary number, said by operating in parallel each task, the database processing unit, characterized in that which enables parallel processing of the first to third processors. 3. The first processor, when a command for instructing quasi-coupling or coupling is given from the host device, transfers the same from the secondary storage device to the first input buffer of the internal memory. A first input processing task that causes the second processor to read the condition table data specified by the command, and is read into the first input buffer under the control of the first input / output processing task. Target table designated by the command from the secondary storage device to the second input buffer of the internal memory, which is activated after the condition table data is loaded into the third processor for a batch processable amount of the same processor. A second input processing task for causing the second processor to read table data, and a condition read into the first input buffer. The condition table data is loaded into the same processor as the batch processable amount in the third processor, and then the target table data read into the second input buffer is subjected to the semi-join or the join given from the host device. An interface processing task for requesting processing to the third processor is generated, and the database arithmetic processing apparatus according to claim 2.