JPS6261118A - Retrieving system for tree structure index - Google Patents

Abstract

PURPOSE:To efficiently retrieve wild cards by forming a means for retrieving objective data from an index table on the basis of the node name of an applied retrieval key and the level No. CONSTITUTION:The minimum key in the succeeding block of a corresponding block is registered as a key to be registered in an auxiliary index table without registering the maximum key in the corresponding block. At the insertion of new data, the data are inserted into a block having an auxiliary index key larger than the key of the data. For instance, an insertion key consisting of (A.M.OBJ.P) is inserted into a block 12 and the change of the auxiliary index key is unnecessary. The retrieval of the wild card consisting of (A.M.OBJ.*) can be attained only by the processing of the block 12.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a data retrieval method in an electronic computer system, and particularly provides an efficient retrieval method for data having a tree-structured index.

[Prior art and problems of the invention]

Conventionally, as a search key for data identified by multiple attributes, the code name of each attribute is connected to form the search key, and the relationship between each data and the search key is established as a tree-structured index. A method of finding target data by following an index based on a search key is well known.

However, the structure of the conventional index and its search method are
This method is not necessarily efficient, and has many inconveniences, especially in so-called wild card searches.

Here, to explain wild card search, for example, data with keys (A, B, FORT) and (
Data with keys (A, C, FORT) and (A, D
, FORT), the search key is (A, *).

This is a method in which all three data items listed above are retrieved when FORT is specified. In other words, it is possible to use a search key that has a don't care part as a search item, which is a very convenient function.

There are three types of designation symbols for this don't care part:

? - 11 characters (alphanumeric characters and symbols) * - 1 attribute code consisting of 1 to 8 characters% - 1 arbitrary number of attribute codes Furthermore, the urinary code is 1 to 8 characters, and between each attribute code shall be separated by periods. Therefore, periods cannot be used in attribute codes, and the above? , *, also does not include a period.

[Purpose of the invention]

An object of the present invention is to provide an index structure and a search method thereof that allow the above-mentioned wild card search to be carried out efficiently.

[Embodiments of the invention]

FIG. 1 is an explanatory diagram of a wild card search method according to an embodiment of the present invention, in which 1 is an index table, 2 is a reference table, 3 is a stack table, and 4 is an index table.
．． Reference numerals 5 and 6 indicate pointers that indicate the reference positions of each table, and are abbreviated as ① pointer, R pointer, and S pointer, respectively. All of these are provided on the main memory of the data processing system. FIG. 2 is a diagram showing an example of a tree-structured index.

In Figure 2 (in al, the characters at the branching points of each technique indicate one attribute code, hereinafter referred to as node names), there is a chain of node names from the highest node name to the lowest node name. This serves as a search key for one piece of data. for example,
The rightmost data is the data to be searched using the search key (A, M, PLl, Q).

Furthermore, the subscript T in the figure indicates that the node is a type node, and it is assumed that there is at most one level below the type node.

FIG. 2(b) is the same figure (al is written horizontally and rearranged so that it is in alphabetical order within the same level.

In the index table 1 in Figure 1, the ■ column is the node name, and the ■ column is the node name.
The level number is shown in the column, the flag indicating that it is a type node is shown in the ■ column, and the next pointer is shown in the ■ column, which can be easily created from FIG. 2(b). The next pointer indicates the position of a node that is at the same level or a higher level than the current node and appears next on this table. However, in the illustrated example, the position is indicated by the distance from the own node. The arrow shown on the right side of the table is for explaining the next pointer.

Further, the order on the index table is such that nodes at the same level follow a fixed order such as alphabetical order.

Using such an index table, for example, (A,
A general method for searching for data having the search keys M, PLI, Q) will be described.

b) First of all, there is no particular problem with A of the Lebel order.

Mouth) In order to search for the next second level M,
Look at the next node.

The node name of this node is D, which does not match M. Then, when looking at the four nodes ahead according to the next pointer, this is also DATA and does not match. Further, according to the next pointer, 2
Looking at the next node, the node name matches M and the target 2
The level node is found.

c) Next, in order to search for the third level PLl, a search similar to the above step) is performed starting from the node OBJ next to node M.

This time, the two nodes ahead of the OBJ pointer are PLI
You can find it easily.

2) Node PLI is a type node. When a type node is reached, the range up to the next type node pointed to by the next pointer of that type node can be searched using a binary search method.

In this example, Q can be found immediately.

In this way, by providing the index table with a level number and a pointer pointing to the next node at the same level, and adding various flags as necessary, efficient searches can be performed.

Next, the wild card search method will be described in accordance with FIG. 1 above. In addition, reference table 2 and stack
Table 3 is provided with columns for node names and their level numbers.

First, wild card search using * will be explained.

a) First, each node name of the search key (A, *, FORT) and its level number are stored in the reference table 2 of FIG. Stack table 3 is initially cleared. Further, each pointer 4, 5, and 6 all have an initial value of 1 and point to the first entry.

b) In this state, first compare the contents of the entry pointed to by R pointer 5 of reference table 2 with the contents of the entry pointed to by pointer 4 of index table 1.

In this example, both are (A) and the level numbers match, so the contents (A) and level numbers are stacked.
Write to the entry pointed to by S pointer 6 in table 3.

Thereafter, each pointer 4, 5, 6 is advanced one step and the next level search is started.

C) If the comparison does not match, add the value of the next pointer to pointer 4 and look at the next node at the same level. If they match, they are written to the stack table 3 in the same way as above, and each pointer 4, 5, 6 is incremented to move on to the next level search. Note that pointer 4 is advanced one step from the position of the found entry.

Incidentally, if it is still not found, it means that there is no data corresponding to this search key.

d) When the entry pointed to by R pointer 5 of reference table 3 is *, only the level numbers are compared and if there is a matching node name, it is written to stack table 3, and each pointer 4.5.6 to move to the next level of search.

e) The R pointer 5 indicates the number of nodes (
This can be determined by looking at the given search key, so it is stored in advance as the upper limit of R pointer 5).When this exceeds the upper limit of R pointer 5, one found key has been completed in stack table 3. . Therefore, the contents of stack table 3 are output, or the data address attached to the lowest level node is output.

f) If the I pointer 4 has not reached the end of the index table 1 at this time, there is a possibility that another corresponding key will exist after that.

Therefore, the I pointer 4 is further incremented sequentially, the R pointer 5 and the S pointer 6 are set to the same level according to the level number of the entry, and the contents of the index table l and the contents of the reference table 2 are compared. I will do it.

Once one key is found, the pointer 2 should point to the lowest level entry, and the next entry should be at a higher level. Therefore, in the reference table 2, each time the R pointer 5 reaches the upper limit value, a new key is found.

g) ■ If pointer 4 matches the final value of index table l, the search has ended.

h) Note that even if * is a search key that exists in multiple locations, the search can be performed in exactly the same manner as above. In either case, the search is completed by scanning the index table l only once.

next? Describe wild card search using

? treats one character in one node name as a don't care. Therefore, when comparing node names in the search using * above, ? It is sufficient to mask the characters at the positions corresponding to the parts and compare them, and the rest is the same as in a) to h) above.

Next, a wild card search method using % will be described. In this case, the search procedure will be slightly different from the above.

i) The initial state is the same as a) above. Also, the steps in b) and c) above are the same until % appears.

j) When % appears on reference table 2, expand a series of node names from the relevant level to the lowest level on index table l onto stack table 3, and combine reference table 2 and each node name. Compare them and if they match down to the lowest level, it will be output as a correct answer.

k) To search for another correct answer, use the next pointer of the index table at the level where the above % appears to check whether there is another node name at the same level. If there is, perform the same process as j) above. If the end of index table 1 is reached, the search ends.

■) If % appears in the middle of the comparison in j) above, the position of % at a lower level will be changed to k) above.
, and recursively perform this process sequentially for % positions at higher levels.

As described above, wild card search is possible.

Furthermore, when an index table becomes large, it is divided into a plurality of blocks and each block is handled individually, but the conventional division method is inconvenient for wild card searches.

Conventionally, when an index table is divided into multiple blocks, an auxiliary index table is provided, and the largest key of each flock (in index table 1 in Figure 1) is stored as the key representing each block. The key corresponding to the node listed in the bottom entry) was used. However, for example, the maximum key of the nth block is (A, B
, C) When the minimum key of the n+l block is (A, D, B), if you try to register new key data of (A, B, E), this is larger than the maximum key of the n block, so , must be inserted into the n+l block.

(If you try to insert the nth block, you will have to change the representative key of the nth block.) As a result, (A
, B, *) when searching for wild cards such as n,
It becomes necessary to refer to both blocks n+1, which complicates the search process.

Therefore, in the present invention, the key to be registered in the auxiliary index table is not the maximum key of the corresponding block, but the minimum key of the next block. Then, when inserting new data, it is inserted into a block that has an auxiliary index key larger than the key of the data.

FIG. 3 shows split index tables 11, 12, 13 and auxiliary index table 14 according to an embodiment of the present invention.
It shows. In this case, for example (A, M, OBJ, P
) will be inserted into block 12, and there is no need to change the auxiliary index key. And (A, M.

OBJ, *) wild card search is block 12
This is possible by processing only the

〔Effect of the invention〕

As described above, by using the index table of the present invention, a wild card search can be realized using a simple algorithm and a simple table.

[Brief explanation of drawings]

FIG. 1 is an explanatory diagram of an embodiment of the present invention, FIG. 2 is a diagram illustrating an example of a tree-structured index, and FIG. 3 is a diagram illustrating an embodiment of an index divided into multiple blocks. 1 is the index table, 2 is the reference table.
Table 3 is a stack table, and 4.5.6 is a pointer to the table to be written. 1yA 21) Figure 2(b) Figure 3

Claims (3)

[Claims] (1) In a method of searching data using a chain of multiple attribute codes as a search key, using a tree-structured index that indicates the relationship between the search key and each data, an index table that stores the above-mentioned index. (1)
In each entry, store at least the node name corresponding to the above attribute code, the level number of the node name, and a pointer pointing to the next entry to appear on the table that has the same or higher level number than the level number. A search for a tree-structured index is characterized in that an index table is provided, and a means is provided for searching for target data by tracing the index table based on the node name and level number of a given search key. method. (2) The above search means has a reference table (
2), a means for comparing and collating each node name and level number of the reference table with each node name and level number of the index table, and a stack for sequentially assembling the node names and level numbers that match as a result of the comparison. A search method for a tree-structured index according to claim (1), characterized in that it includes a table (3). (3) The above index table (1) consists of a plurality of blocks (11, 12, 13) and an auxiliary index table (14) storing representative keys of each block,
The tree according to claim (1) or (2), characterized in that each representative key of the auxiliary index table stores the smallest key in the block following the corresponding block. Structure index search method.