KR970002416B1 - Extendible chained-bucket hash structure for high performance data search - Google Patents

Abstract

An Extensible Chained-Bucket Hash(ECBH) structure for use in the main memory of a database system is provided to enhance retrieving speed of a desired record. The structure comprises an Extensible Hash (EH) table for maintaining global depth provided for interleaving/deletion of a record; a plurality of Chained-Bucket Hash (CBH) table for maintaining local depth; and a record identifier (RID) given by the computer.

Description

Extended Bucket Chain Hash Structure for High Performance Data Retrieval

1 is a block diagram showing the present invention briefly.

2 illustrates a hardware environment in which the present invention is used.

3 is a block diagram of the present invention according to an embodiment.

4 is a flowchart illustrating an initialization process of the present invention.

5 is a flow chart showing the retrieval of records through the index of the present invention.

6 is a flowchart showing a process of inserting a record identifier according to the present invention.

7 is a flowchart illustrating a deletion process of a record identifier according to the present invention.

The present invention relates to a high-performance data retrieval method, specifically, in a main memory database system that loads and retrieves all data into a main memory device, a desired record can be searched by comparing a plurality of key values through a key for a large data. It also relates to the structure of an extended bucket chain hash (ECBH), which can maintain its performance even with data deletion / insertion.

The prior art in this field is largely divided into two.

First, there are linear hashes and extended hashes (hereinafter referred to as EHs) for materials stored on disk.

The above techniques are easy to change the search structure by inserting / deleting data, but they are not suitable for main memory because their main purpose is to reduce the number of disk I / O.

Second, a bucket-chain hash (CBH) structure is known to be the fastest as a hash structure used in main memory.

However, this method does not have the scalability of the structure, so if a lot of changes occur due to the insertion / deletion of the data, it may not show the original performance and may slow down or waste the main memory too much.

Therefore, for the high performance data retrieval for the main memory resident database as described above, the structure is expanded without having a great effect on performance / space even for data changes such as EH while having a very fast retrieval speed like the existing CBH structure. It should be possible.

Therefore, an object of the present invention is to provide a high-performance data retrieval structure having a fast search and expandability at the same time. The following describes the invention with reference to the accompanying drawings. FIG. 1 is a block diagram schematically showing an ECBH structure for quickly accessing a large number of records stored in a main memory of a database system through a key.

A record consists of several data items, in which the user creates an ECBH for the item that he wants to access quickly. The key of the above item is referred to. A method of searching for a record having a specific key value through ECBH is as follows.

First, it searches for entries in the extended hash table by hashing the given key value. That is, the bucket chain hash table is identified.

Second, hash the given key value again to find the entry in the bucket chain hash table.

Third, the record is searched through each record identifier attached to the entry to find the record with the given key.

2 is a view showing the operating environment of the main memory upper database system for understanding the ECBH structure of the present invention. Load all data into main memory to use the database stored on disk.

A database consists of files, a collection of records of the same kind as many records, and ECBHs for fast data retrieval through key values.

All calculations are performed by the CPU, and the disk is used as a backup of data in case of system failure or power failure.

Each record stored in the main memory has a unique record identifier (hereinafter referred to as RID). Access to the record through the RID is possible with a plurality of CPU instructions.

However, RIDs are assigned by computers and have no meaning to users. Use key values (e.g. social security number, employee number) to retrieve the records you want.

Therefore, the database system must have a search structure that searches RIDs quickly through key values. ECBH is for this purpose and has a structure as shown in FIG.

In preparation for inserting / deleting records, the EH maintains a global depth and a local depth for each CBH. The global depth is the log of the number of entries in the current valid EH table, and the local depth is the log value of the number of EH table entries pointing to the CBH table minus the global depth. In the example of FIG. 3, the number of entries in the EH table is eight, so the global depth is log8 = 3.

For the last CBH, the region depth is 3-log4 = 1 because it is shared by four entries in the EH table.

The following describes the operation of ECBH and can be divided into ECBH initialization, record search, insertion, and deletion through ECBH.

The flowchart is used for clarity of explanation, and the following symbols are used in the flowchart. The numbers in parentheses in the upper right of the icon in the flowchart are used to explain the flowchart.

Constants:

GD-ECBH Global Depth

CBH_SIZE-The size (number of entries) of one CBH table, which is a prime number.

Average chain length limit of CBH to perform SP-division (user adjusted)

The number of RIDs stored in CBH indicating when to check the CP-split condition (adjusted by user)

Operators:

hash () -hash function

2 ^** B multiplier of B-2

Shift bits of AB-A right by B

Shift bits of AB-A left by B

Bitwise AND with AB-A

Bitwise OR of A | B-A and B

A ^ B-A and B bitwise XOR

A% B-A divided by B

Variable and data structure notation:

A [i]-represents the i-th value of array A, and when array A has N values, i has a value from 0 to N-1. That is, A [0], A [1], ..., A [N-1].

EH EH table of E.EH-ECBH color

EH [i] —ith entry of the EH table E

Total chain length of C.CL-CBH table C

Area Depth of C.LD-CBH Table C

Number of RIDs stored in C.N-C

I th entry of C [j] -C

List of RIDs dependent on the i th entry of C [j] .L-C

C [j] .N-List of RIDs depending on the i th entry of -C Number of stored RIDs

RID value of one node L in L.RID-RID list

The next node of one node L in the L.NEXT-RID list

5 is a flow chart showing the initialization process. Reference numeral (1) indicates that one ECBH initially has one empty CBH, and the EH table initially has 2 ^** GD entries, and a key is inserted / deleted. It does not change even in the hour.

5 is a flowchart showing a process of retrieving records through the ECBH index. Hash the given key value to find the location in the CBH table and CBH table where the RID of the record to find is stored.

(2 of FIG. 5)

Then, it searches the actual record while following the RID list starting from the entry of the CBH table found above, and returns the RID at this time when a record having a given key value is found.

(3 of FIG. 5)

6 is a flowchart showing a process of inserting an RID into an ECBH. The search of FIG. 5 determines the location of the CBH table into which a given RID is to be inserted (4 of FIG. 6).

A new node with the given RID information of the RID list of the positions determined above is inserted (5 in FIG. 6). And it reflects the statistical information (RID number, total chain length) changed by the inserted new node (5 in Fig. 6).

If the number of RIDs currently stored in the CBH is a multiple of the CP determined by the user, a search is performed to determine whether division is necessary (6 in FIG. 6). The reason for not checking it at every insertion is to maximize the cost of the test.

Subsequently, in the flowchart of the insertion procedure of the RID for the ECBH shown in FIG. 6, the division is stopped under the following conditions.

(7 of FIG. 6)

1. If the area depth of CBH is the same as that of ECBH,

(Initial allocation of EH table at first)

2. The number of RIDs currently stored in CBH is smaller than CBH_SIZE (for efficient use of storage space).

3. The average chain length does not reach the user defined split limit.

Allocate a new CBH and initialize it as shown in Figure 4.

(8 of Figure 6)

When the hash value is recalculated for all RIDs of the RID list of each entry of the CBH table to be partitioned, and the area depth is increased by one, the new CBH is moved to the newly allocated CBH.

(9 of Figure 6)

At this time, various statistics of the original CBH and the new CBH are appropriately changed. Increase the area depth of the split CBH and newly allocated CBH by one.

(10 of FIG. 6)

In the EH table, change the middle of the entries that pointed to the original CBH to point to the new CBH.

(11 in Fig. 6)

The partitioned CBH and the newly allocated CBH may need to be partitioned again after the above partitioning process.

(12 of FIG. 6)

For example, if all RIDs of the original CBH have been transferred to the new CBH, it may be necessary to repartition the new CBH. This recursive repartitioning attempt always ends within a certain degree because the regional depth increases with each division, and the regional depth cannot exceed the global depth by the conditions shown in (7) of FIG.

7 is a flowchart illustrating a RID deletion process in ECBH. The search of FIG. 5 obtains the CBH table in which a given RID is located, a corresponding entry, a list node, and the like. (13 in Fig. 7)

Delete the node from the RID list and change the relevant statistics (number of RIDs, chain length).

(14 of Fig. 7)

If the number of RIDs stored in the current CBH is a multiple of the CP determined by the user, the merger is checked.

(15 in Fig. 7)

The reason for not checking on every deletion is to minimize the cost of the check.

An area depth of zero means that the ECBH consists of only one CBH (16 in Figure 7). Get the CBH of the entry with the same value when reducing the local depth of the current CBH by 1 in the EH table.

(17 in Fig. 7)

This is now called a buddy of CBH. That is, the current CBH and the partner CBH are CBHs that are divided by division.

If the current CBH and partner CBH have different regional depths, they cannot merge. That is, the number of pairs is plural.

(18 in Fig. 7)

It may later merge with each other and then with the current CBH. Moves all RID lists in the pair to the current CBH and changes the relevant statistics.

(19 in Fig. 7)

Returns the memory space allocated to the partner and decrements the current depth of the current CBH by one.

(20 in Fig. 7)

Write the current CBH to the corresponding entry in the EH table.

(21 in Fig. 7)

Merged CBH may need to be merged with a new partner again. To this end, the merger will be checked again. Therefore, according to the above, the present invention has the following effects.

First, it is very fast because it uses the CBH structure to retrieve records by key value.

Second, by putting the expandable EH in the front position, the entire CBH table is not reorganized even when the record is inserted / deleted.

Third, the user can adjust the desired search performance and the required space, so it can be used for files with different application characteristics.

Claims (1)

A database system comprising: an extended hash table (EH) table for maintaining global depth in preparation for inserting / deleting records, a plurality of bucket chain hash (CBH) tables for maintaining local depth, and a record identifier (RID) given by a computer. Extended bucket chain hash structure for high performance data retrieval, characterized in that consisting of.