JP2010218326A - Code string search device, search method and program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a code string search method that performs retrieval for an optional code string by finding a data structure of index which can be created in a shorter time than before and using the data structure. <P>SOLUTION: In accordance with a code string block obtained by dividing a code string to be searched into a plurality of blocks, a code-specific ID range table storing the range of code ID by code and an ID relationship table storing the next code ID located next to each code ID are created, a next code ID stored in accordance with a code ID included in the code ID range of the head code of a search code string is read out from the ID relationship table, the next code IDs stored in accordance with the next codes are read out sequentially from the ID relationship table, a code including the next code ID thus read out in the range of code ID is searched from a code-specific ID range reading table, and then the searched codes are collated sequentially with the codes in the search code string following the head code. <P>COPYRIGHT: (C)2010,JPO&INPIT

Description

  The present invention relates to a code string search for searching for a code or code string composed of a bit string by a computer, such as a character string search for retrieving a character code composed of a bit string or a character code string.

  In recent years, it has become common to use word processors to create business documents, and with the widespread use of the Internet, there seems to be a large amount of electronic documents that can be processed by computers using character codes consisting of bit strings. It has become. For this reason, various character string search methods have been developed in order to search for necessary ones among these large amounts of electronic documents using a computer.

  In these character string search methods, it is common to create an index in advance in order to realize a high-speed search. As an index, for example, a transposed index in which words in a document are extracted and a document name included in each word is associated is well known. This inverted index is characterized by its relatively small size, high speed search, and simple index construction. However, there are languages where word extraction is difficult. In addition, when searching for a combination of a plurality of words, there is a drawback in that processing for matching word positions in a document is required. It is also difficult to search for an arbitrary character string in a sentence.

Therefore, an index called a suffix array has been developed that makes it possible to search for an arbitrary character string. The following Patent Document 1 and Non-Patent Document 1 disclose a suffix array and a search method using the suffix array.
FIG. 1 illustrates an example of a conventional search method relating to the suffix arrangement described above. FIG. 1A illustrates a character string to be searched. As shown in the figure, the character string 10 is composed of alphabetic characters A, B, C, E and a delimiter character $. The character A is located at the character positions 1, 4, and 7 of the character string 10. The character B is located at the character positions 2 and 5 of the character string 10. The character C is located at the character positions 6 and 8 of the character string 10. The character E is located at the character position 3 of the character string 10. The delimiter character $ is located at the character position 9 which is the last position of the character string 10.

FIG. 1B shows a suffix 20 in character position order, a suffix 20a in dictionary order, and a suffix array 30.
The character string 10 can be considered to have a suffix of 9 as its partial character string as shown in FIG. By sorting the suffixes 20 in the character position order in which the suffixes are arranged in the character position order of the first character of each suffix, the suffixes 20a in the dictionary order are obtained. At this time, the suffix array 30 is obtained by storing the character positions of the first characters of the suffixes sorted in the dictionary order in the array. With this suffix array, it is possible to obtain the leading character position of the partial character string in the search target character string that matches the pattern of the search character string.

  FIG. 1C illustrates the concept of character string search using a compressed suffix array. A compressed suffix array (conceptual diagram) 50 corresponding to the search character string 40 and the suffix array 30 is shown in FIG. It is shown. The next array number (Ψ) is stored in the array number (i) of the compression suffix array (conceptual diagram) 50. The next array number (Ψ) is the array element number of the suffix array 30 in which the character position obtained by adding 1 to the character position stored in the array element number (i) of the suffix array 30 is stored.

  By changing what is stored in the array from the character position to the next array number (Ψ), the values stored for each character are in ascending order as shown in the figure. Therefore, since the value stored in each array element can be the increment of the value stored in the previous array element, not the next array number (Ψ) itself, the bit width can be reduced, and the amount of information Can be compressed.

  Regarding the concept of the search, the dotted line arrow from each character of the exemplified search character string 40 to the array number (i) of the compressed suffix array (conceptual diagram) 50 and the bold letters of the array number (i) 3, 6 , 9 and the next step of searching for an arrow between 6 and 9 shown in bold in the sequence number (Ψ). That is, for example, 3 is selected from the sequence numbers corresponding to the first character A of the search character string 40, and the sequence number 6 next to the sequence number 3 is the sequence number corresponding to the second character B of the search character string 40. Since the sequence number 9 next to the sequence number 6 is the sequence number corresponding to the third character E of the search character string 40, it is found that the search target character string 10 is hit by the search by the search character string 40. .

Japanese Patent No. 3,672,242

Sadakane, “Consideration on Compression Suffix”, IEICE Technical Report (2000-7-19) Vol.100, No.226, p49-56

By using a compression suffix array for character string search, an arbitrary character string can be searched, and the capacity of the array can be reduced. However, before creating a compressed suffix array, it is necessary to create a suffix array from the search target character string, sort the suffixes in dictionary order, and create a suffix array. The processing time for creating a compressed suffix array from a long time becomes large.
Therefore, the problem to be solved by the present invention is to reduce the time for creating index data that can search for an arbitrary code string, not just a character string, as compared with the conventional one. An object of the present invention is to provide an index data structure that can be searched for an arbitrary code string and can be created in a shorter time than before, and to provide a code string search method using the index data structure. It is.

According to the present invention, the search target code string is divided into several blocks (hereinafter also referred to as code string blocks), and each code string located in the code string block is uniquely assigned to each code string block. The code ID to be identified is a different code value (hereinafter, when there is no possibility of misunderstanding, it may be simply referred to as a code. Conversely, it may be referred to as a code type by emphasizing that it is a different code value. .)) So that the code ID ranges do not overlap each other. For example, by assigning code IDs in ascending order for each code in the order in which they appear in the code string block, by repeating the value of the first code ID for each code type as a value larger than the code ID assigned so far, the above code ID assignment can be realized.
According to the present invention, the code-specific ID range table storing the range of the code ID for each code corresponding to each code string block and the next code ID which is the code ID positioned next to each code ID are stored. An ID relationship table is created, and a code string search is performed using the ID range table for each code and the ID relationship table.

According to the code string search of the search target code string by the search code string of the present invention, the range of the code ID of the code constituting the search code string is read from the code-specific ID range table of the first code string block, and the search code string The next code ID stored corresponding to the code ID included in the code ID range of the first code of the code is read from the ID relation table created for each code string block, and the next code ID stored corresponding to the next code ID is stored. The code ID is sequentially read from the ID relation table, the code corresponding to the entry in the ID range table for each code including the next code ID read from the ID relation table in the code ID range is obtained, and the obtained code and the search code string Whether the next code matches the next code is sequentially checked, and this check is similarly performed on the subsequent code string block.

  According to the present invention, it is possible to perform a search using a code-specific ID range table and an ID relation table having a simple structure, so that it is not necessary to create a suffix array, and the processing load of computer index creation is reduced. can do.

It is a figure explaining the example of the conventional search method regarding a suffix arrangement | sequence. It is a figure explaining the functional block for creating the data structure for the index in one embodiment of this invention. It is a figure explaining the functional block for the code string search in one embodiment of this invention. It is a figure explaining the hardware structural example in one embodiment of this invention. It is a figure explaining the structure of the index data in one Embodiment of this invention. It is a figure explaining the concept of the code string search in one embodiment of this invention. It is a figure explaining the process flow of the front | former stage which produces the index data of the code string block in one Embodiment of this invention. It is a figure explaining the process flow of the back | latter stage which produces the index data of the code string block in one Embodiment of this invention. It is a figure explaining the schematic flow of the process which produces the index data of the code string block in one Embodiment of this invention. It is a figure explaining the processing flow which counts the frequency | count of appearance for every code classification of the code contained in the code sequence of the search object in one Embodiment of this invention. It is a figure explaining the processing flow which sets the code ID range of the ID range table classified by code based on the frequency | count of appearance in one Embodiment of this invention. It is a figure explaining the processing flow which completes an ID relationship table based on the code contained in the search object code sequence in one Embodiment of this invention. It is a figure explaining the general | schematic flow of the whole process of the code string search in one Embodiment of this invention. It is a figure explaining the processing flow of the front | former stage of the code sequence search which makes a certain code sequence block the search start position in one Embodiment of this invention. It is a figure explaining the processing flow of the back | latter stage of the code string search which makes a certain code string block a search start position in one Embodiment of this invention. It is a figure explaining the processing flow of the exact matching search in one embodiment of this invention. It is a figure explaining the processing flow of the front matching search in one embodiment of this invention. It is a figure explaining the processing flow of the search containing the arbitrary codes in one embodiment of this invention. It is a figure explaining the processing flow which converts code ID into code in one embodiment of this invention. It is a figure explaining the processing flow of the front | former stage of the search of the following code sequence block in one embodiment of this invention. It is a figure explaining the processing flow of the back | latter stage of the search of the next code sequence block in one embodiment of this invention. It is a figure explaining the flow of the process of the search from the head code sequence block in one embodiment of this invention. It is a figure explaining the flow which transfers to the search of the next code sequence block in one embodiment of this invention. It is a figure explaining the flow of the processing of the search from the 2nd code string block from the head in one embodiment of this invention.

Hereinafter, the best mode for carrying out the present invention will be described with reference to the drawings.
FIG. 2A is a diagram illustrating functional blocks for creating an index data structure according to an embodiment of the present invention. The index data creation management means 104 manages the creation of index data for each block (code string block) obtained by dividing the search target code string by the index data creation means 105, and creates an index data management table. The index data creation unit 105 includes a search target code string reading unit 101, a code-specific ID range table generation unit 102, and an ID relation table generation unit 103.
The search target code string is read by the search target code string reading unit 101 and passed to the code-specific ID range table generating unit 102 and the ID relation table generating unit 103. The code-specific ID range table generating unit 102 creates a code-specific ID range table storing the range of the code ID for each code, and the ID relation table generating unit 103 is a code ID positioned next to each code ID. An ID relation table storing the next code ID is generated.

  FIG. 2B is a diagram illustrating functional blocks for performing a code string search according to an embodiment of the present invention. The code string search management unit 116 manages the search for each code string block of the search target code string by the code string search unit 117. The code string search means 117 includes a search code string reading means 111, a code-specific ID range reading means 112, an ID relation reading means 113, a code type searching means 114, and a code type checking means 115.

First, the top code of the search code string is read by the search code string reading unit 111 and passed to the code-specific ID range reading unit 112. The code-specific ID range reading unit 112 reads the code ID range of the first code passed from the search code string reading unit 111 from the code-specific ID range table generated by the code-specific ID range table generation unit 102 to obtain an ID. The data is transferred to the relationship reading unit 113.

The ID relation reading unit 113 generates an ID relation table by generating the next code ID stored corresponding to the code ID included in the code ID range of the first code in the search code string passed from the ID range reading unit 112 by code. In addition to reading from the ID relationship table generated by the means 103, the next code ID stored corresponding to the next code is sequentially read from the ID relationship table and passed to the code type search means 114.
The code type searching unit 114 searches for a code type including the next code ID passed from the ID relation reading unit 113 in the range of the code ID using the code ID range table and passes the code type to the code type checking unit 115.
The code type collating unit 115 collates the code type read by the search code string reading unit 111 with the code type searched by the code type searching unit 114 and outputs a search result.

FIG. 2C is a diagram illustrating an exemplary hardware configuration according to an embodiment of the present invention.
Search processing and index generation processing by the search device of the present invention are performed by a data processing device 301 including at least a central processing unit 302 and a cache memory 303 using a data storage device 308. The data storage device 308 including the storage region of the index data management table 321 and the index data storage region 324 for storing the ID range table 309 and the ID relation table 310 corresponding to the code string block is the main storage device 305 or external It can be realized by the storage device 306, or a remote device connected via the communication device 307 can be used.

Each function block such as the code string search unit 117 described with reference to FIGS. 2A and 2B can be realized by hardware illustrated in FIG. 2C and software including steps described later.

In the example of FIG. 2C, the main storage device 305, the external storage device 306, and the communication device 307 are connected to the data processing device 301 by one bus 304, but the connection method is not limited to this. In addition, the main storage device 305 can be in the data processing device 301.
Although not particularly illustrated, it is natural that a temporary storage area corresponding to each process is used in order to use various values obtained during the process in a later process. In the following description, the value stored or set in the temporary storage area may be called by the name of the temporary storage area.

Next, an outline of a search method in one embodiment of the present invention will be described.
FIG. 3A is a diagram for explaining the structure of index data according to an embodiment of the present invention. FIG. 3A shows an example of a search target code string for which index data is to be created. The exemplified search target code string 10a is composed of alphabetic character codes of codes A, B, E, A, B, C, A,. P1 to P8,..., Pn-1 and Pn described below each character code represent the position of the code in the search target code string 10a. The code position pointer 11 is a pointer indicating the position of the code in the search target code string 10a, and points to the code position P1 in the illustrated example.
In the example shown in the figure, the search target code string 10a is divided into four codes. Therefore, as indicated by the arrow 12, the head position of the second code string block is P5. As indicated by an arrow 13, the end position of the second code string block is P8. The code position Pn indicated by the arrow 14 is defined as the end position. Only the last code string block is composed of two codes.
For each code string block, a code-specific ID range table and an ID relationship table are generated as index data.

FIG. 3B shows an example of the data structure of an index for code string search, and an index generated corresponding to the search target code string and its code string block shown in FIG. Data management table 321 and code-specific ID range table 309a and ID relation table 310a stored in the index data storage area 324a corresponding to the first code string block The index data storage area corresponding to the second code string block ID range table 309b by code stored in 324b and ID relation table 310b, index data storage area 324c corresponding to the third code string block, and index data storage area 324d corresponding to the last code string block The code-specific ID range table 309d and the ID relation table 310d are illustrated. The notation of the index data stored in the index data storage area 324c is omitted. In the following description, common items may be described using notations such as “ID range table by code 309” and “ID relation table 310”. In addition, other codes may be similarly described.
An entry in the code-specific ID range table 309 is created for each type of different code that appears in a search target code string that is a target for creating index data. As shown on the left side of the code-specific ID range table 309, in the example shown in the figure, a search target code string that is a code string composed of codes A to E among alphabets is a target for creating index data. An entry is created for each code. The code type pointer 311 is a pointer that points to an entry in the code-specific ID range table 309. In the example of the code-specific ID range table 309a corresponding to the top code string block in the figure, the code type pointer 311a points to the entry corresponding to the code A. Similarly, in the example of the code-specific ID range table 309b corresponding to the second code string block, the code type pointer 311b points to the entry corresponding to the code A. In the example of the code ID range table 309d corresponding to the last code string block, the code type pointer 311d points to the entry corresponding to the code A.
Since each code is composed of a bit string, it has a value represented by the bit value of the bit string. Therefore, it is clear that the position of the entry corresponding to each code in the code-specific ID range table 309 can be associated with the value of each code. That is, the value taken by the code type pointer 311 can be the code itself. Therefore, in the following description, an entry corresponding to each code may be described as an entry indicated by each code.

As displayed below the code-specific ID range table 309a, the entry of the code-specific ID range table 309a includes items of setting display, appearance count, start code ID, end code ID, and code-specific ID counter. ing.
The setting display indicates by 1 or 0 whether the code appears in the corresponding code string block. In the example of the code-specific ID range table 309a, since the code C and the code D do not appear in the first code string block, the entries of the code C and the code D are 0, and the other entries are 1. In the example of the code-specific ID range table 309b, since the code D and the code E do not appear in the second code string block, the entries of the code D and the code E are 0, and the other entries are 1. In the example of the code-specific ID range table 309D, only the code B and the code C appear in the last code string block, so the entries of the code B and the code C are 1, and the other entries are 0.
The number of appearances is the number of times the code appears in the corresponding code string block. In the example of the code-specific ID range table 309a, 2, 1, 0, 0, 1 are stored for code A to code E. In the example of the ID range table 309b by code, 1, 1, 2, 0, 0 are stored for the code A to the code E. In the example of the code-specific ID range table 309d, 0, 1, 1, 0, 0 are stored for code A to code E.

The head code ID and the tail code ID indicate a range of code IDs for each code. The code ID is assigned for each code in the order of appearance in the code string block so that the codes do not overlap.
In the example of the code ID range table 309a, the number of appearances for code A is 2, so the range of code IDs is ID1 to ID2, and for the next code B, the number of appearances is 1. Are both ID3. Since the number of appearances of code C and code D is 0, neither the start code ID nor the end code ID is set. For code E, the number of appearances is 1, so that the head code and the tail code are both ID4.
Similarly, in the example of the code-specific ID range table 309b, the first code and the last code of the code A are both ID1, the first code and the last code of the code B are both ID2, and the number of appearances is 2 for the code C. The range of ID is ID3 to ID4.
In the example of the code-specific ID range table 309d, the first code and the last code of the code B are both ID1, and the first code and the last code of the code C are both ID2.

  Specifically, the value such as ID1 is preferably an integer value starting from 1, but is not limited thereto, and any value can be used as long as it can identify an ID range for each code. In the example of the figure, the range of the code ID is indicated by the head code ID and the tail code ID. However, if it is willing to be variable length data, it can also be indicated by listing all the code IDs.

The code-specific ID counter is a counter that is necessary when generating the ID-related table after generating the code-specific ID range table, and is not necessary as index data. Accordingly, a counter different from the code-specific ID range table can be provided for each different code type.

  An entry in the ID relationship table 310 is created for each code ID assigned to the code in the code string block. As shown on the left side of the ID relationship table 310, in the example shown in the figure, entries are created corresponding to the code ID1 to code ID4 except for the link table 310d of the last code string block. Each entry is composed of items of code position and next code ID. The code ID pointer 312 is a pointer that points to an entry in the ID relationship table 310. In the example of the figure, the ID ID pointer 312 points to ID1 in any ID relationship table 310.

The code position of each code ID entry is the code position in the search target code string 10a where the code of the code ID is located. In the ID relationship table 310a, P1 is stored for ID1, P4 for ID2, P2 for ID3, and P3 for ID4.
As indicated by the dotted arrow 313a (A) in the figure, the first and second entries of the ID relationship table 310a correspond to the code A. Similarly, the third entry corresponds to the code B as indicated by the dotted arrow 313a (B), and the fourth entry corresponds to the code E as indicated by the dotted arrow 313a (E).
The next code ID of each code ID entry is the code ID of the code positioned next to the code of the code ID in the code string block. For the code at the end position of the code string block, the code ID of the code at the start position is stored. Therefore, in the ID relationship table 310a, ID3 is stored as ID3 for ID1, ID1 for ID2, ID4 for ID3, and ID2 for ID4.

In the ID relationship table 310b, P7 is stored for ID1, P5 for ID2, P6 for ID3, and P8 for ID4.
As indicated by the dotted arrow 313b (A) in the figure, the first entry in the ID relationship table 310b corresponds to the code A. Similarly, the second entry corresponds to the code B as indicated by the dotted arrow 313b (B), and the third to fourth entries correspond to the code C as indicated by the dotted arrow 313b (C).
As the next code ID, ID4 is stored for ID1, ID3 is stored for ID2, ID1 is stored for ID3, and ID2 is stored for ID4.

In the ID relationship table 310d, Pn is stored for ID1 and Pn-1 is stored for ID2.
As indicated by the dotted arrow 313d (B) in the figure, the first entry in the ID relationship table 310d corresponds to the code B. Similarly, the second entry corresponds to the code C, as indicated by the dotted arrow 313d (C).
As the next code ID, ID2 is stored for ID1, and ID1 is stored for ID2.

  The ID relationship table 310 holds, as index data, that two codes represented by code IDs are in a continuous positional relationship in a code string block. The relationship between the code at the end position of the front code string block and the code at the head position of the rear code string block is managed by having the index data management table 321 have the head code of each code string block.

As shown in the figure, the index data management table 321 has an entry for each code string block, and each entry includes items of setting display, head code, and index data pointer. The index data management pointer 322 is a pointer that points to an entry in the index data management table. In the example of the figure, the index data management pointer 322 points to the entry 1 corresponding to the head code string block.
In the setting display of the index data management table 321, 1 is set from entry 1 to entry m, and the setting display of the other entries is 0. The entry m corresponds to the last code string block. In addition, as a head code of the index data management table 321, a code A is set for entry 1, a code B is set for entry 2, and a code C is set for entry m.
The index data pointers point to the index data storage areas 324a, 324b, 324c, and 324d of the corresponding code string blocks, as indicated by dotted arrows 344a, 344b, 344c, and 344d.

Comparing the ID relationship table 310 with the conventional compression suffix array 50 shown in FIG. 1C, the compression suffix array 50 sorts the next array number for each character. In the table 310, code positions are sorted for different code types. Therefore, when the same code is searched sequentially, the speed can be increased by the cache effect.

FIG. 3B is a diagram for explaining the concept of code string search according to an embodiment of the present invention.
The search target code string is the search target code string 10a illustrated in FIG. 3A, and is divided into code string blocks as shown in FIG. 3A. Further, the concept of the code string search will be described as the search code string 40a shown in FIG. 3B. Assume that the code-specific ID range table 309 and the ID relation table 310 are generated and the index data management table 321 is generated corresponding to the code string block of the search target code string 10a.
Before starting the search, the head entry 321 (1) of the index data management table indicated by the arrow 348a is read and stored in the index data storage area 324a by the index data pointer 342a as indicated by the dotted arrow 344a. The code-specific ID range table 309a and the ID relation table 310a are acquired. Further, as indicated by the dotted arrow 343a, the entry 309a (A) of the code-specific ID range table 309a corresponding to the code A stored in the head code 341a is read, and as indicated by the dotted arrow 345a, ID1, which is the head code ID, is read and set to the head code ID 346a, which is a temporary storage area.

In the search code string 40a, as shown in the drawing, code E, code A, code B, and code C are located from the top. Therefore, the code E, which is the first code 332a, is read as indicated by the dotted arrow 331a in the figure. Next, as indicated by a dotted arrow 333a, an entry 309a (E) corresponding to the code E in the code-specific ID range table 309a corresponding to the head code string block is read. (If the head code of the search code string 40a does not exist in the head code string block, the index data corresponding to the code string block in which the head code exists is skipped.)
As indicated by the dotted arrow 334a, the code ID included in the ID range 336a, that is, the code ID4 in the example shown in the figure, is read from the entry 309a (E), and the entry 310a (4) corresponding to the read code ID4. Are read from the ID relationship table 310a.

On the other hand, the first code of code A, which is the first code set in the code string ID range table 309a, and ID1 are set as the first code ID 346a, which is a temporary storage area.
Then, as shown by a two-way dotted arrow 347a, ID2 that is the next code ID of the entry 310a (4) corresponding to code ID4 and ID1 set in the head code ID 346a are compared, and the next code ID is the head. It is determined that it is other than the code ID.

Then, as shown by a dotted arrow 331b, the code A which is the second code 332b is read out.
On the other hand, as indicated by a two-way dotted arrow 335b, ID2 that is the next code ID 337a of the entry 310a (4) corresponding to the code ID4 of the ID relation table 310a indicates the code A of the code-specific ID range table 309a. It is determined that it is included in the code ID range 336b (ID1 to ID2). This determination can be performed by sequentially extracting the code ID range from the top entry of the code-specific ID range table 309a and determining whether the range includes ID2.
As indicated by a dotted arrow 351a in the figure, a code A (hereinafter also referred to as an index code) indicating a code ID range table 309a entry that includes ID2 that is the next code ID 337a in the range of the code ID is temporarily. It is determined that the code A, which is the index code set in the temporary storage area 352a, matches the code A, which is the second code 332b, as indicated by the bidirectional dotted arrow 353a, which is set in the storage area 352a. The
This means that the code sequence of code E and code A exists in the first code string block of the search target code string 10a. Since the code position 338a of the entry 310a (4) corresponding to the code ID 4 read from the ID relation table 310a is P3, the top position of the code sequence of the code E and code A is P3. I understand.

Further, as indicated by a dotted arrow 334b, ID1 that is the next code ID 337b of the entry 310a (2) corresponding to ID2 that is the next code ID 337a is read. Then, as indicated by a bidirectional dotted arrow 347b, the read ID1 is compared with the ID1 previously set in the head code ID 346a, and it is determined that the next code ID and the head code ID are equal. Is done. That is, it is determined that the code A of the code ID2 of the first code string block to be compared with the code A that is the second code 332b is located at the end position of the first code string block.
Then, the second entry 321 (2) of the index data management table indicated by the dotted arrow 348b is read, and the code B stored in the head code 341b is stored in the temporary storage area 352b as indicated by the dotted arrow 351b. Is set. When the code B is read as the third code 332c as indicated by the dotted arrow 331c, it is determined whether or not it matches the code set in the temporary storage area 352b as indicated by the bidirectional dotted arrow 353b. Is done. That is, it is determined whether the code B which is the third code 332c is the head code of the second code string block. In the illustrated example, a positive determination result is obtained. Therefore, it can be seen that the search target code string 10a hits the search code string EAB.

Therefore, the index data storage area 324b is accessed by the index data pointer 342b as indicated by the dotted arrow 344b, and the ID by code corresponding to the code B stored in the head code 341b as indicated by the dotted arrow 343b. The entry 309b (B) in the range table 309b is read. As indicated by the dotted arrow 345c, ID2 that is the first code ID in the code ID range 336f is read and set to the first code ID 346b that is a temporary storage area.
Next, as indicated by a dotted arrow 334c, ID3 which is the next code ID 337c of the entry 310b (2) corresponding to ID2 which is the head code ID 346b is read. Then, as indicated by a bidirectional dotted arrow 347c, the read ID3 is compared with ID2 previously set to the head code ID 346b, and it is determined that the next code ID is other than the head code ID. Is done.

Then, as indicated by a dotted arrow 331d, the code C which is the fourth code 332d is read out.
On the other hand, as indicated by the bidirectional dotted arrow 335d, ID3, which is the next code ID 337c of the entry 310b (2) corresponding to the code ID2 of the ID relation table 310b, is indicated by the code C of the ID range table 309b for each code. It is determined that it is included in the code ID range 336d (ID3 to ID4). That is, the code indicating the code-specific ID range table 309b including ID3 in the range of the code ID is found to be the code C.
Therefore, it can be seen that the search target code string 10a hits the search code string EABC.
Following this determination, as indicated by a dotted arrow 334d, ID1 that is the next code ID 337d of the entry 310b (3) corresponding to ID3 that is the next code ID 337c is read. Then, as indicated by the bidirectional dotted arrow 347d, the read ID1 is compared with the ID2 previously set in the head code ID 346b, and the next code ID and the head code ID may not be equal. Determined.
Then, the code position 338b of the entry 310a (2) corresponding to the code ID2 read from the ID relation table 310a is P4, and the entry 310b (2) corresponding to the code ID2 read from the ID relation table 310b. Since the code position 338c is P5 and the code position 338d of the entry 310b (3) corresponding to the code ID3 is P6, it can be seen that the hit positions are the code positions P3, P4, P5, and P6. .

Also for the fifth code (not shown) of the search code string 40a, the next code ID of the entry in the ID relationship table 310 corresponding to ID1 that is the next code ID 337d is read as shown by the dotted arrow 334e. The determination of whether or not the code ID is within the code ID range of the entry in the code ID range table 309 indicated by the code type of the code is repeated.
As described above, the code string search according to the embodiment of the present invention is performed.

Next, index data creation processing according to an embodiment of the present invention will be described. The index data is composed of an index data management table, an ID management table for each code stored in an index data storage area corresponding to each code string block, and an ID relationship table, as illustrated in FIG. 3A (b). The
4A and 4B are diagrams illustrating a flow of processing for creating index data according to an embodiment of the present invention. The index data creation processing flow shown in FIG. 4A and FIG. 4B includes initial processing and index data corresponding to each code string block (hereinafter referred to as block index data corresponding to each code string block or simply block index data). It may consist of a flow that sequentially executes the creation process.

FIG. 4A is a diagram for explaining the processing flow before the process of creating index data according to an embodiment of the present invention, that is, the process of sequentially creating block index data corresponding to each code string block. This preceding process is the initial process described above.
As shown in FIG. 4A, a search target code string is set in step S401. The search target code string is set by reading one code string from the set of search target code strings stored in the data storage device by the search target code string reading unit 111 illustrated in FIG. This means setting in the code string setting area. The above-described search target code string setting area is one of the above-described “temporary storage devices corresponding to each process in order to use various values obtained during the process in the subsequent process”. . In the following explanation, instead of the expression “set in a search target code string setting area (not shown)”, it is described as “set as a search target code string” or simply “set as a search target code string”. Sometimes. The same applies to other than the search target code string.

In step S402, the storage area of the index data management table is acquired, and the index data management pointer is positioned at the first entry of the index data management table. In step S403, the maximum number of codes in the code string block obtained by dividing the search target code string is set. In the example shown in FIG. 3A, the maximum number of codes is four. In the next step S404, the head position of the code position to be searched is set as the head position of the code string. In step S405, the end position of the code string to be searched is set as the end position of the code string, and the process proceeds to step S406 shown in FIG. 4B.
This completes the initial process of creating index data. In the example of FIG. 3A, the search target code string 10a is set, the index data management pointer 322 is positioned at the head entry of the index data management 321, the maximum code number is 4, and the code string head position is P1. However, Pn is set at the end position of the code string.

FIG. 4B is a diagram for explaining a processing flow at the latter stage of processing for sequentially creating block index data corresponding to each code string block.
As shown in the figure, in step S406, a value obtained by subtracting the head position of the code string from the end position of the code string is set in the remaining code number, and in step S407, it is determined whether the remaining code number is larger than the maximum code number. .
If the remaining code number is larger than the maximum code number, the process proceeds to step S408, and the position moved by the maximum code number from the head position of the code string is set as the end position of the code string. If the remaining code number is not greater than the maximum code number, the process advances to step S409 to set the end position of the code string at the end position of the code string.
The processes in steps S406 to S409 described above are performed in order to determine the end of index data creation processing corresponding to each code string block described later, based on the end position of the code string set in step S408 or step S409.

  In step S410, a storage area for the index data of the code string block that is the current index data creation target is secured, a pointer to the storage area is acquired, and the process proceeds to step S411. The code string block for which the index data is to be created starts from a code positioned at the head position of the code string set in step S404 or step S415 described later.

  In step S411, the index data of the code string block that is the current index data creation target is created, stored in the storage area secured in step S410, and the topmost code is acquired. Details of the processing in step S411 and the top code will be described later with reference to FIG. 4C and FIGS. 5A to 5C.

  In step S412, “present” is set in the setting display of the index data management table pointed to by the index data pointer, the top code is set in the top code, and the pointer acquired in step S410 is set in the index data pointer. Note that the top code is set in the process of step S411.

In step S413, it is determined whether the end position of the code string is the end position of the code string. If the end position of the code string is the end position of the code string, the creation of the index data has been completed, and the process ends. If the end position of the code string is not the end position of the code string, the process proceeds to step S414, the index data management pointer is positioned at the next entry in the index data management table, and the code string end position is set at the head position of the code string in step S415. The code position next to the position is set, and the process returns to step S406.
The loop processing from step S406 to step S415 is repeated until it is determined in step S413 that the end position of the code string indicates the end position of the code string, and if the determination is obtained, index data for all code strings is obtained. Since the creation of the index data has been completed, the index data creation process is terminated.

Next, as detailed description of step S411 shown in FIG. 4B, block index data creation processing according to an embodiment of the present invention will be described. Since this block index data creation process is the same for any code string block, and the code string block is also a single code string, in the following description, the code that is currently the target of index data creation The column block may be referred to as a search target code string or a search target code string.

FIG. 4C is a diagram illustrating a schematic flow of processing for creating block index data according to an embodiment of the present invention.
First, in step S420, the area of the ID range table for each code is secured based on the number of code types to be searched, and the codes included in the search target code string are sequentially read to show the number of appearances and the total number of codes for each code type. Ask for. The total number of codes in the case of the first code string block shown in FIG. 3A is 4, which is equal to the maximum code number set in step S403 shown in FIG. 4A.
Details of the processing in step S420 will be described later with reference to FIG. 5A.

  Next, in step S430, a code ID range for each code type is set in the code-specific ID range table based on the number of appearances for each code type. Details of the processing in step S430 will be described later with reference to FIG. 5B.

Next, in step S440, the area of the ID relation table is secured based on the total number of codes, and the ID relation table is completed by sequentially reading out the codes included in the search target code string while referring to the code-specific ID range table. The process is terminated. Details of the processing in step S440 will be described later with reference to FIG. 5C.

FIG. 5A shows a detailed flow of the processing in step S420 shown in FIG. 4B, and is a diagram for explaining the processing flow for counting the number of appearances for each code type of codes included in the search target code string.

  As shown in the figure, in step S501, a search target code string is set. Setting the search target code string means that the code string block that is currently the target of index data creation is set in a search target code string setting area (not shown). The above-described search target code string setting area is one of the above-described “temporary storage devices corresponding to each process in order to use various values obtained during the process in the subsequent process”. . In the following explanation, instead of the expression “set in a search target code string setting area (not shown)”, it is described as “set as a search target code string” or simply “set as a search target code string”. Sometimes. The same applies to other than the search target code string.

  In step S502, the number of code types is set. The number of types of codes is determined by the code system and is given in advance. In step S503, a storage area for the ID range table for each code is secured in the area secured in step S410 shown in FIG. 4B based on the number of code types set in step S502, and the number of appearances is set to 0. initialize. Subsequently, in step S504, the head position of the code string set in step S501 is set in the code position pointer, and in step S505, a value 0 is set in the code number counter. The processes in steps S501 to S505 described above are initial processes.

  Progressing to step S506 following the initial processing, the code pointed to by the code position pointer is extracted from the code string. Next, in step S507, a value 1 is added to the number of appearances of an entry in the ID range table for each code corresponding to the code type of the extracted code (hereinafter also referred to as a code-specific ID range table indicated by the code), and step S508 is performed. The value 1 is added to the code number counter, and the process proceeds to step S509.

In step S509, it is determined whether the code position pointer is the end position of the code string set in step S408 or step S409 of FIG. 4B. If it is not the end position, the code position pointer is advanced to the next code position in step S510. The process returns to step S506. If the code position pointer is the end position of the code string, the code number counter is set as the total number of codes in step S511, and the process is terminated.
Through the above processing, the number of appearances of the code-specific ID range table is set, and the total number of codes is set.

  FIG. 5B shows a detailed flow of the process in step S430 shown in FIG. 4C, and shows a process flow for setting a code ID range for each code type based on the number of appearances set by the process shown in FIG. 5A. It is a figure explaining.

  First, in step S521, the head position of the code ID range table is set in the code type pointer, and in step S522, an initial value is set in the code ID counter. In step S523, the number of appearances is extracted from the code-specific ID range table indicated by the code type pointer. In step S524, it is determined whether the number of appearances extracted is zero.

  If the number of appearances is not 0, “Yes” is set in the setting display of the code ID range table pointed to by the code type pointer in step S525, and the value of the code ID counter is set in the head code ID and the code ID counter. . Next, in step S526, the number of appearances is added to the code ID counter, and in step S527, a value obtained by subtracting 1 from the value of the code ID counter is set in the tail code ID of the code ID range table pointed to by the code type pointer, and in step S529. Proceed to

  On the other hand, if the number of appearances is 0 in the determination in step S524, “None” is set in the setting display of the code ID range table pointed to by the code type pointer in step S528, and the code pointed to by the code type pointer in step S528a. An unset ID is set in the head code ID and the tail code ID of the separate ID range table, and the process proceeds to step S529. As the unset ID, 0 or -1 can be used.

  In step S529, it is determined whether the code type pointer is the end position of the code-specific ID range table. If it is not the end position, the code type pointer is advanced to the position of the next code type in the code-specific ID range table in step S530. The process returns to step S523. If it is the end position, since the setting of the code-specific ID range table has been completed, the processing ends.

  FIG. 5C shows a detailed flow of the processing in step S430 shown in FIG. 4C, and is a diagram for explaining the processing flow for completing the ID relationship table based on the codes included in the search target code string.

  First, in step S541, a storage area for the ID relation table is secured in the storage area secured in step S410 of FIG. 4B based on the total number of codes obtained by the process shown in FIG. 5B. In step S542, the code position pointer is stored. The head position of the search target code string is set. Next, in step S543, the code pointed to by the code position pointer is extracted from the search target code string, and is set as the first code. In step S544, the code-specific ID counter in the code-specific ID range table pointed to by the code is read and set in the code ID pointer. Next, in step S545, a code ID pointer is set to the topmost code ID, and the process proceeds to step S546.

  In step S546, it is determined whether the code position pointer is the end position of the code string set in step S408 or step S409 of FIG. 4B. If the code position pointer is not the end position of the code string, the processing of steps S547 to S554 is executed. The code position and the next code ID in the ID relation table indicated by the corresponding code ID are set, and the process returns to step S546.

First, in step S547, a code position pointer is set at the code position in the ID relation table pointed to by the code ID pointer.
In step S550, 1 is added to the code ID counter in the code ID range table pointed to by the code extracted in step S543 or step S552, and the code position pointer is advanced to the next code position in step S551.

Next, in step S552, the code pointed to by the code position pointer is extracted from the search target code string, and in step S553, the code-specific ID counter in the code-specific ID range table pointed to by the extracted code is read, and the ID relationship pointed to by the code ID counter Set to the next code ID in the table.

In step S554, the code ID counter read in step S553 is set in the code ID counter, and the process returns to step S546. The processes in steps S546 to S554 described above are repeated until the code position pointer points to the end position of the search target code string. When the code position pointer reaches the end position or end position of the search target code string, the process branches to step S555. In step S555, the code position pointer is set in the code position of the ID relation table pointed to by the code ID pointer, and the top code ID set in step S545 is set in the next code ID, and the process is terminated.
Index data for code string search according to an embodiment of the present invention is created by the processing described in detail with reference to FIGS. 4A to 5C.

  Next, a code string search process according to an embodiment of the present invention will be described with reference to FIGS. As described above with reference to FIG. 3B, the code string search according to the embodiment of the present invention is first the code in the search target code string that matches the head code of the search code string and its position. A code position is obtained, and a code-by-code ID range table corresponding to the code string block is created for each code collation between the code in the search target code string and the code in the search code string from the obtained code position. This is performed using an ID relationship table.

Therefore, before entering a specific description with reference to FIG. 6 to FIG. 9B, an overview of the processing flow of the code string search processing and the relationship between the processing described in each drawing in the embodiment of the present invention will be described.
The processing flow of the code string search in one embodiment of the present invention has a triple loop.
The outermost loop is a loop for each code string block. The search by the search code string is repeated from the first code string block to the last code string block of the search target code string. The control flow of this outermost loop is shown in FIG.
The next inner loop is a loop for each code ID of the head code of the search code string. In a certain code string block, the search by the search code string is repeated over the range of the code ID of the head code of the search code string. The control flow of this loop is shown in FIGS. 7A and 7B.
The innermost loop is a loop for collation with the code string block for each code of the search code string. The verification for each code from the head code to the tail code of the search code string is repeated. The control flow of this innermost loop is shown in FIG. 8A for an exact match search, in FIG. 8B for a forward match search, and in FIG. 8C for a search that includes an arbitrary code.
FIG. 8D describes a processing flow for obtaining a code having the code ID from the code ID, which is common to FIGS. 8A to 8C.

According to the processing flow of the code string search process in one embodiment of the present invention, the next inner loop process is called for each code string block of the outermost loop process, and for each code ID of the head code of the search code string The innermost loop process is called to repeat the verification for each code from the first code to the last code of each code in the code string block and the search code string.
In the present invention, when the search target code string is divided for each code string block, and the above-mentioned verification for each code is repeated in the innermost loop processing, the verification of the code at the end of the search code string is performed. It is possible that the end position of the code string block may be reached before the process ends. Then, it is necessary to continue the above-mentioned collation for each code over the next code string block.
The search process for the next code string block whose processing flow is shown in FIGS. 9A and 9B realizes the continuation of the verification for each code. This search processing is called by the innermost loop processing, but the innermost loop processing is called recursively for repeated verification for each code.

  FIG. 6 is as described above, and is therefore a diagram for explaining the general flow of the entire code string search process in one embodiment of the present invention. The flow shown in FIG. 6 includes an initial process and a loop process in which a search is started by sequentially switching a code string block to be searched from a search target code string from the top to the next code string block.

First, in step S601, a search code string is set. The search code string is set by setting the search code string read by the search code string reading means 111 shown in FIG. 2B in the temporary storage area, and the start position of the set search code string is given. It is assumed that
In step S602, the head entry position of the index data management table is set in the index data management pointer at the search start position which is a temporary storage area.
This completes the initial processing described above.

  In step S603, the index data management table entry pointed to by the index data pointer at the search start position is extracted. In step S604, it is determined whether the setting display of the extracted entry is “Yes”. If the setting display is “present”, the process proceeds to step S605. If the setting display is not “present”, all searches are completed, and the process is terminated.

In step S605, the index data pointer of the entry extracted in step S603 is extracted, and the code-specific ID range table and ID relation table stored in the index data storage area pointed to by the index data pointer are acquired. The ID range table for each code and the ID relationship table are acquired when the storage areas of the ID range table for each code and the ID relationship table are secured in step S503 shown in FIG. 5A and step S541 shown in FIG. 5C, respectively. This can be realized by setting respective pointers pointing to and using those pointers.

In step S606, the top code of the entry extracted in step S603 is extracted. In step S607, the head code ID is extracted from the ID range table by code pointed to by the head code, and set as the head code ID at the search start position.
Next, in step S608, the corresponding code string block is searched based on the code-specific ID range table and ID relationship table acquired in step S605. Details of the processing in step S608 will be described later with reference to FIGS. 7A and 7B.
In step S609, the next entry position in the index data management table is set in the index management data pointer at the search start position, and the process returns to step S603.

The loop processing from step S603 to step S609 described above is performed until it is determined in step 604 that the index data management table entry setting display is not “present” while the index data management pointer at the search start position is updated in step S609. repeat.
The index data management pointer setting process at the search start position in steps S602 and S609 and the start code position setting process in step S607 are performed from the code string block starting the search as described above. Since there is a case where collation for each code is performed over the block, the index data management pointer and the head code position relating to the code string block for starting the search are saved.

Next, the search processing in step S608 shown in FIG. 6 will be described in detail with reference to FIGS. 7A and 7B.
FIG. 7A is a diagram for explaining the processing flow of the previous stage of code string search performed using a certain code string block as the code string block at the search start position in one embodiment of the present invention.
First, in step S701, the start position of the search code string is set as the search start position, and in step S702, the end position of the search code string is set as the search end position.

In step S703, the search code is extracted from the search code string pointed to by the search head position, and set as the search code at the search head position. In step S704, a setting display is extracted from the code-specific ID range table indicated by the search code at the search head position, and in step S705, the setting display for determining whether the extracted setting display is “present” is not “present”. Since the search code at the search start position does not exist in the search target code string, the search process is terminated.

If the determination in step S705 is that the setting display is “Yes”, the process proceeds to step S706, where the head code ID is extracted from the code-specific ID range table indicated by the search code at the search head position, and is set as the search start code ID. In step S707, the end code ID is extracted from the code-specific ID range table indicated by the search code at the search start position and set as the search end code ID.
In the processing of step S706, the search start code ID, which is the code ID being processed in the loop processing for each code ID of the head code of the search code string described above, is initialized to the head code ID in the range of the code ID. The processing in step 707 is for making it possible to identify the end of the code ID to be processed.
Subsequent to step S707, the process proceeds to step S711 shown in FIG. 7B.

FIG. 7B is a diagram illustrating a processing flow of the latter stage of code string search performed using a certain code string block as a code string block at a search start position according to an embodiment of the present invention.
In step S711, the search head position set in step S701 is set as the search progress position. The search progress position indicates the code position of the code to be collated in the collation loop with the code string block for each code of the search code string shown in FIG. 8A and the like described above. In step S711, the search head Initially set to the position, that is, the start position of the search code string.
Next, in step S712, the index data management pointer at the search start position set in step S602 shown in FIG. 6 is set in the index data management pointer, and in step S713, the head code ID which is a temporary storage area is shown in FIG. The head code ID of the search start position set in step S607 is set. In step S714, the search start code ID is saved and the process proceeds to step S715.

Here, the search start code ID is saved because there is a possibility that the code string is collated over a plurality of code string blocks as described above in the process of step S715. In that case, the process of FIG. 8A and the like is recursively called, and at that time, the first code ID of the ID range table by code pointed to by the first code of the next code string block (corresponding to the next code string block) This is because the search start code ID may be changed.

In step S715, the above-described search is performed by collating each code from the code in the code string block to the code at the beginning of the search code string to the code at the end. It returns whether the search was successful or unsuccessful. Details of step S715 will be described later with reference to FIG. 8A regarding complete match search, FIG. 8B regarding forward match search, and FIG. 8C regarding search including an arbitrary code.

In step S716, the search start code ID saved in step S714 is restored. In step S717, an entry in the index data management table pointed to by the index data management pointer at the search start position is extracted. In step S718, each code stored in the index data storage area pointed to by the index data pointer in the extracted entry is stored. An ID range table and an ID relationship table are acquired. As described above, in the processes in steps S717 and S718, there is a possibility that code strings are collated over a plurality of code string blocks in the process in step S715. In this case, in FIG. Since the code-specific ID range table and ID relationship table that are different from the code-specific ID range table and ID relationship table acquired in step S605 are used, the search start position set in step S602 or step S607 of FIG. The code-specific ID range table and ID relation table are obtained again using the index data management pointer.

In step S719, it is determined whether the search in step S715 was successful or unsuccessful. If unsuccessful, the process proceeds to step S721. If successful, in step S720, the code position is extracted from the ID relationship table pointed to by the search start code ID, and is output to the search result code position, and the process proceeds to step S721.

In step S721, it is determined whether the search start code ID matches the search end code ID. If not, the search start code ID is updated to the next code ID in step S722, and the process returns to step S711.
If the search start code ID and the search end code ID match, the search of the code ID range in the code-specific ID range table pointed to by the first code of the search code string in the currently processed code string block has been completed. Returning to the processing shown in FIG.

Next, with reference to FIG. 8A, FIG. 8B, and FIG. 8C, the process of step S715 shown to FIG. 7B is demonstrated in detail. As described above, the process in step S715 is performed as shown in FIG. 8A, FIG. 8B, or FIG. 8C depending on whether the search mode is a complete match search, a forward match search, or a search including an arbitrary code. It will be illustrated as follows.

FIG. 8A is a diagram for explaining the processing flow of an exact match search in one embodiment of the present invention.
As shown in the figure, the search start code ID is set in the code ID pointer in step S810. This search start code ID is either initially set in step S706 shown in FIG. 7A or updated and set in step S722 shown in FIG. 7B. Next, in step S811, the next code ID is extracted from the ID relationship table pointed to by the code ID pointer, set as a search code ID, and set as a code ID pointer.

Next, in step S812, it is determined whether the search progress position is the search end position. If it is not the search end position, the process proceeds to step S813. If it is the search end position, it is confirmed that the collation for each code succeeds to the end of the search code string. Therefore, the search success is returned and the process returns to the loop process shown in FIG. 7B.
In step S813, it is determined whether the next code ID extracted in step S811 matches the head code ID. The head code ID is set in step S713 shown in FIG. 7B. If the next code ID and the head code ID do not match, the process proceeds to step S814, the search progress position is advanced to the position of the next search code in the search code string, and the search is performed from the search code string indicated by the search progress position in step S815. The code is extracted and the process proceeds to step S816.

In step S816, the code-specific ID range table is searched using the next code ID, and the corresponding index code is extracted. The index code is the code having the next code ID as the code ID as described above with reference to FIG. 3B. The next code ID is included in the range of the code ID in the code-specific ID range table pointed to by the index code. Details of the processing in step S816 will be described later with reference to FIG. 8D.
In step S817, it is determined whether the search code extracted in step S815 matches the index code extracted in step S816. If they match, the process returns to step S811, and if they do not match, there is a code that could not be verified. Therefore, the search failure is returned and the process returns to the loop process shown in FIG. 7B.

  On the other hand, if it is determined in step S813 that the next code ID and the head code ID match, the process proceeds to step S818 to search for the next code string block. Details of the processing in step S818 will be described later with reference to FIGS. 9A and 9B.

  In step S819, it is determined whether the search for the next code string block is successful. If successful, search success is returned. If not successful, search failure is returned and the process returns to the loop processing shown in FIG. 7B.

  FIG. 8B is a diagram for explaining the process flow of the forward match search in one embodiment of the present invention. Compared with the processing flow of the exact match search shown in FIG. 8A, the processing itself executed in each step of steps S830 to S838 shown in FIG. 8B is the step shown in FIG. 8A with the step number obtained by subtracting 20 from the step number. This is the same as the process executed in steps S810 to S818.

However, in step S817 of complete match search shown in FIG. 8A, if it is determined that the search code does not match the index code, search failure is returned and the process returns to the process shown in FIG. 7B, whereas the forward match search shown in FIG. In step S837, even if it is determined that the search code does not match the index code, search success is returned and the process returns to the loop processing shown in FIG. 7B.
In step S831, code positions are sequentially extracted in addition to the next code ID from the entry in the ID relationship table pointed to by the code ID pointer. When it is determined in step S837 that the search code does not match the index code, step S831 is executed. The code position extracted last may be returned as a search result together with a successful search. The last extracted code position is the code position stored in the same entry in the ID relationship table with the next code ID included in the code ID range of the index code described above. The codes up to the search target code string located at this code position match the search codes in the search code string. The last extracted code position and the code position extracted from the ID relationship table pointed to by the search start code in step S720 shown in FIG. You can know the range of code positions.

  Further, after searching for the next code string block in step S818 of the exact match search shown in FIG. 8A, it is determined in step S819 whether the search for the next code string block is successful. If the search is not successful, a search failure is returned and the process returns to the loop processing shown in FIG. 7B. On the other hand, in the forward match search shown in FIG. 8B, the search succeeds immediately after searching for the next code string block in step S838. Then, the processing returns to the loop processing shown in FIG. 7B.

This is because it is ensured by the determination processing in step S705 shown in FIG. 7A that the first search code in the search code string exists in the search target code string, and therefore at least the first code in the search code string is included. Since a matching code string exists in the search target code string, the search is returned to success and the process returns to the loop processing shown in FIG. 7B.
Since the return type after the determination in step S837 and the processing other than step S838 and subsequent steps are all the same as those shown in FIG. 8A as described above, description thereof will be omitted.

  FIG. 8C is a diagram illustrating a search processing flow including an arbitrary code according to the embodiment of this invention. Here, the arbitrary code is a code that is collated with an arbitrary code in the search target code string. If the search code string includes an arbitrary code and a code string that matches all the codes other than the arbitrary code exists in the search target code string, the search target code string is hit with the search code string including the arbitrary code.

When the flow shown in FIG. 8C is compared with the processing flow of the exact match search shown in FIG. 8A, the processing executed in each step from step S850 to step S859 shown in FIG. 8C is the processing in step S855a between step S855 and step S856. Is the same as the processing executed in steps S810 to S819 shown in FIG. 8A for the step number obtained by subtracting 40 from the step number.

In step S855a, it is determined whether the search code extracted in step S855 is an arbitrary code. If it is determined in step S855a that the code is an arbitrary code, the process returns to step S851 without performing the matching determination process between the search code and the index code in steps S856 and S857. If it is not determined in step S855a that the code is an arbitrary code, the process proceeds to step S856.
Except for the determination process in step S855a described above, all the steps are the same as those shown in FIG.

Next, the code ID range table is searched by the next code ID in step S816 shown in FIG. 8A, step S836 shown in FIG. 8B, or step S856 shown in FIG. The process of converting into code will be described in detail.
FIG. 8D is a diagram illustrating a processing flow of processing for converting a code ID into a code according to an embodiment of the present invention.

As shown in the figure, in step S870, an initial value is set in the code type pointer. The code type pointer has already been described with reference to FIG. 3A. For example, as shown in FIG. 3A, the code type pointer 311a points to an entry of the ID management table 309a for each code stored in the index data storage area 324a. The code type pointer for setting the initial value in step S870 is for the code-specific ID range table acquired in step S605 shown in FIG. 6 or step S911 shown in FIG. 9B described later.

Next, in step S871, the head code ID and tail code ID are extracted from the entry in the code ID range table pointed to by the code type pointer, and in step S872, it is determined whether the search code ID is within the range of the head code ID and tail code ID. .

If the search code ID is not within the range of the head code ID and the tail code ID, it is determined in step S873 whether the code type pointer is the end position of the ID range table by code, and if it is not the end position, the code type pointer is determined in step S874. The process advances to the next position in the ID range table for each code and returns to step S871. If it is determined in step S873 that the code type pointer is the end position of the code-specific ID range table, the process advances to step S876 to set an undetermined code in the index code and the process ends.

On the other hand, if it is determined in step S872 that the search code ID is within the range of the head code ID and the tail code ID, the process proceeds to step S875.
In step S875, the code type pointer is set in the index code, and the process ends. As understood from the description of the concept of the code string search with reference to FIG. 3B, the value of the code type pointer is associated with a specific code type including the code itself. Thus, setting the code type pointer in the index code here means setting the specific code type associated with the value of the code type pointer in the index code which is a temporary storage area.
The index code search has been described with reference to the so-called linear search method in which the search code ID and the code ID range are matched while sequentially updating the code type pointer from the initial value. However, the search method is not limited to this, and it is obvious that any search method such as a binary search method can be adopted.

Next, the search processing for the next code string block in step S818 shown in FIG. 8A, step S838 shown in FIG. 8B, or step S858 shown in FIG. 8C will be described in detail.
FIG. 9A is a diagram for explaining the first stage of the processing flow for searching for the next code string block in the embodiment of the present invention.

As shown in the figure, in step S901, the next entry position of the index data management table is set in the index data management pointer. At this time, the index data management pointer at the search start position is set as the index data management pointer in step S712 shown in FIG. 7B. In step S902, an entry in the index data management table pointed to by the index data management pointer is extracted. In step S903, it is determined whether the setting display of the extracted entry is “Yes”.

If the setting display is “Yes”, the process proceeds to step S904. If the setting display is not “Yes”, there are no more code string blocks, and verification for each code is interrupted. The process returns to the process of FIG. 8A, FIG. 8B or FIG.

On the other hand, in step S903, it is determined that the entry setting display is “Yes”, and when the process proceeds to step S904, the head code of the entry in the index management table taken out in step S902 is taken out and set as the head code which is a temporary storage area. To do. Next, in step S905, the search progress position is advanced to the position of the next search code in the search code string. In step S906, the search code is extracted from the search code string indicated by the search progress position, and the process proceeds to step S907.

In step S907, it is determined whether the head code set in step S904 matches the search code extracted in step S906. This determination is a comparison between the code at the head position of the next code string block and the code at the search progress position of the search code string. If this determination result is negative, search failure is returned and the processing returns to FIG. 8A, FIG. 8B or FIG. 8C.
On the other hand, if the determination result in step S907 is affirmative, the process proceeds to step S911 and subsequent steps shown in FIG. 9B, and collation for each code is further advanced.

FIG. 9B is a diagram for explaining the latter part of the processing flow of the search for the next code string block in the embodiment of the present invention.
In step S911, the code-specific ID range table and ID relation table stored in the storage area of the index data pointed to by the index data pointer of the entry previously extracted in step S902 shown in FIG. 9A are acquired.

Next, in step S912, the head code ID is extracted from the code-specific ID table pointed to by the head code set in step S904, set to the head code ID which is a temporary storage area, and in step S913, the head code ID is set as the search start code ID. Then, the process proceeds to step S914.

In step S914, the process shown in FIG. 8A, FIG. 8B, or FIG. 8C is recursively called, and a search is performed by collating each code from the first code to the last code of each code in the code string block and the search code string. Do. It returns whether the search was successful or unsuccessful.
In step S915, if the search in step S914 is successful, search success is returned, and if it is unsuccessful, search failure is returned, and the process returns to the process shown in FIG. 8A, FIG. 8B, or FIG.

The embodiment of the present invention has been described in detail above. In the following, in order to further facilitate understanding of the present invention, the flow of the exact match search process in the code string search according to the embodiment of the present invention will be described with reference to FIGS. 10A to 10C. In the examples shown in FIGS. 10A to 10C, the search target code string is one up to the second code string block of those shown in FIG. 3A, and the search code string is ABC. Hereinafter, the search target code string may be referred to as a search target code string 10a in the same manner as in FIG. 3A.

10A and 10B are diagrams for explaining the flow of processing from the top code string block of the search target code string. The outermost loop process shown in FIG. 6 corresponds to the first loop process. .
FIG. 10A illustrates the search flow for the first code string block.
In the figure, a block surrounded by a dotted line denoted by reference numeral 701a describes a flow for processing each search code of the search code string ABC from the top. In other words, the block 701a indicates a change in the code of the search progress position. A block surrounded by a dotted line with a reference numeral 702a includes a code ID range in the code-specific ID range table 309a pointed to by the code at the search progress position and a code-specific ID range pointed to by the code A at the head position of the code string block. ID1 which is the head code ID of the table 309a is described. A block surrounded by a dotted line denoted by reference numeral 703a describes a flow for sequentially obtaining the next code from the ID relation table 310a.
Also, what is shown in parentheses in the figure are the processing steps shown in FIGS. 6 to 9B related to the processing flow shown in the figure.

  As a process before starting the search, as shown by an arrow 731a in the figure, in step S603 of FIG. 6 (in the following description, the drawing number notation is omitted), the top entry 704a of the index data management table is displayed. It is taken out. Then, as shown by an arrow 734a in the figure, in step S605, the code-specific ID range table 309a and the ID relation table 310a stored in the index data storage area 705a are acquired based on the index data pointer 733a of the entry. Then, as indicated by the dotted arrow 735a, in steps S606 and S607, the entry 309a (A) in the code-specific ID range table 309a corresponding to the code A stored in the head code 732a of the entry 704a is read. The head code ID ID1 is read and set to the head code ID 742a.

First, the code A located at the head of the search code string is extracted in step S703 as indicated by the block 701a, and as indicated by the arrow 723a to the block 702a, the head code ID of the code-specific ID range table 309a indicated by the code A is shown. ID1 is extracted in step S706 and set as the search start code ID. Further, ID2 which is the tail code ID is extracted in step S707 and set as the search end code ID.
Next, as indicated by an arrow 724a from ID1 of the block 702a to the block 703a, ID3 which is the next code ID of the ID relationship table 310a pointed to by ID1 is extracted in steps S810 and S811. Then, in step S813, as shown by a bidirectional dotted arrow 736a between ID3 which is the next code ID of the ID relation table 310a pointed to by ID1 in the block 703a and the head code ID 742a in the block 702a, in step S813 It is determined that ID3, which is an ID, is different from ID1, which is the head code ID.

Then, as indicated by an arrow 721a from code A to code B in block 701a, the code at the next code position becomes the processing target in step S814, and code B is extracted in step S815. As shown by the dotted arrow 755b between the ID3 which is the next code ID of the ID relation table 310a pointed to by ID1 in the block 703a and the ID range table 309a by code of the block 702a, in step S816, the code ID range table 309a. In the code ID range including ID3 which is the next code ID, and in the example shown in the figure, code B which is the code indicating the entry is temporarily stored as indicated by a dotted arrow 751a. It is set in area 752a.

Then, as indicated by a bidirectional dotted arrow 753b, in step S817, it is determined that the code B set in the temporary storage area 752a matches the code B extracted in step S815.
Then, as indicated by an arrow 724b in the block 703a, ID4 which is the next code ID of the ID relation table 310a pointed to by ID3 is extracted in step S811. Then, in step S813, as shown by a bidirectional dotted arrow 736b between ID4 which is the next code ID of the ID relationship table 310a pointed to by ID3 in block 703a and the head code ID 742a in block 702a, the next code It is determined that ID4, which is the ID, is different from ID1, which is the head code ID.

Next, as indicated by the arrow 721b from the code B to the code C in the block 701a, the code at the next code position becomes the processing target in step S814, and the code C is extracted in step S815. As indicated by a dotted arrow 755c between ID4, which is the next code ID of the ID relationship table 310a pointed to by ID3 in block 703a, and an ID range table 309a by code in block 702a, in step S816, an ID range table 309a by code In the code ID range including ID4 which is the next code ID, and in the example shown in the figure, a code E which is a code indicating the entry is temporarily stored as indicated by a dotted arrow 751b. It is set in the area 752b.
Then, as indicated by a bidirectional dotted arrow 753c, in step S817, it is determined that the code E set in the temporary storage area 752b does not match the code C extracted in step S815, and the search fails. Therefore, the search failure is returned and the processing returns to the loop processing shown in FIG. 7B.
That is, the code string from the code A whose code ID is ID1 among the code string blocks at the head of the search target code string 10a does not match the search code string ABC. This is because the code string of 3 codes from the code A whose code ID is ID1 in the head code string block of the search target code string 10a is ABE as shown in FIG. Consistent with not being.

FIG. 10B shows a flow in which the search code ID ABC of the search code string ABC is searched from the top code string block as ID2 which is the code ID next to ID1 of code A in step S722. In the loop process shown in FIG. 7B, the process shown in FIG. 10A is the first process, and the process shown in FIG. 10B is the second process.
In the second processing, the search target code string and the search code string are collated over the next code string block after the first code string block.

As indicated by the arrow in block 702a in FIG. 10B, the search start code ID is updated from ID1 to ID2 in step S722 of the loop processing shown in FIG. 7B. Then, as indicated by an arrow 724b from ID2 of the block 702a to the block 703a, ID1 that is the next code ID of the ID relationship table 310a pointed to by ID2 is extracted in steps S810 and S811. In step S813, as shown by a bidirectional dotted arrow 736c between ID1 which is the next code ID of the ID relationship table 310a pointed to by ID2 in block 703a and the head code ID 742a in block 702a, the next code It is determined that ID1 that is the ID matches ID1 that is the head code ID.

Then, as indicated by the dotted arrow 737a, in step S901, the entry 704b next to the first entry 704a in the index data management table is extracted. Then, the code B stored in the head code 732b of the entry 704b is set to the head code ID 741b in step S904 as indicated by an arrow 738a in the figure.

On the other hand, as indicated by an arrow 721a from code A to code B in block 701a, the code at the next code position is processed in step S905, and the code B next to the first code A from the search code string in step S906. Is taken out. Then, as indicated by the bidirectional dotted arrow 744b, in step S907, it is determined that the code B, which is the code positioned next to the code A, matches the code B set in the head code 741.
Then, as shown by an arrow 739a in the figure, in step S911, the code-specific ID range table 309b and the ID relation table 310b stored in the index data storage area 705b are acquired based on the index data pointer 733b of the entry 704b.

Next, as shown by an arrow 745b, in step S912, ID2 which is the head code ID is extracted from the ID-specific ID range table 309b pointed to by the code B set in the head code 741b, and is set as the head code ID 742b.
Subsequently, as indicated by an arrow 724c, ID3 which is the next code ID of the ID relation table 310b pointed to by ID2 is extracted in step S913 and step S811 of the process shown in FIG. 8A recursively called. Then, in step S813, as shown by a bidirectional dotted arrow 736d between ID3 which is the next code ID of the ID relation table 310b pointed to by ID2 of the block 703b and the head code ID 742b of the block 702b, in step S813 It is determined that ID3 which is an ID is different from ID2 which is the head code ID.

Therefore, as indicated by the arrow 721b from the code B to the code C in the block 701a, the code at the next code position becomes the processing target in step S814, and the code C is extracted in step S815. As shown by a dotted arrow 755d between ID3 which is the next code ID of the ID relation table 310b pointed to by ID2 in the block 703b and the ID range table 309b by code in the block 702b, in step S816, the ID range table 309a by code is shown. In the code ID range including ID3 which is the next code ID, and in the example shown in the figure, the code C which is the code indicating the entry is temporarily stored as indicated by a dotted arrow 751d. It is set in area 752d.

  Then, as indicated by a bidirectional dotted arrow 753d, in step S817, it is determined that the code C set in the temporary storage area 752d matches the code C extracted in step S815.

That is, it is shown that the code string from the code A whose code ID is ID2 in the search target code string 10a matches the search code string ABC. This is consistent with the fact that the code string from the code A whose code ID is ID2 in the search target code string 10a is ABC as shown in FIG. 3A (a).
Therefore, in step S720, as indicated by the arrow 728a, the code position P4 of the ID relationship table 310a pointed to by ID2 which is the search start code ID is set at the search result code position indicated by reference numeral 705b.

  Since the search start code ID ID2 is the search end code ID set in step S707, the search using the first code string block as the search start position ends, and the process returns to the loop processing shown in FIG. The search start position is advanced by one, that is, the search is performed from the second code string block from the top.

FIG. 10C is a diagram for explaining the flow of processing from the second code string block of the search target code string, and the outermost loop process shown in FIG. 6 corresponds to the second loop process. The processing flow described below is the same as that described above with reference to FIG. 10A.
As processing before starting the search, as indicated by an arrow 731b in the figure, the value of the index data management pointer at the search start position is updated in step S609, and the top entry 704b of the index data management table is extracted in step S603. . Then, as shown by an arrow 734b in the figure, in step S605, the code-specific ID range table 309b and the ID relation table 310b stored in the index data storage area 705b are acquired based on the index data pointer 733b of the entry.

At the beginning of the search from the second code string block, the code A located at the head of the search code string is extracted again in step S703 as shown in block 701a. Then, as indicated by an arrow 723e to the block 702b, ID1 that is the first code ID of the code-specific ID range table 309b pointed to by the code A is extracted in step S706 and set as the search start code ID. Further, ID1, which is the tail code ID, is extracted in step S707 and set as the search end code ID.
Next, as indicated by an arrow 724d from ID1 of the block 702b to the block 703b, ID4, which is the next code ID of the ID relationship table 310b pointed to by ID1, is extracted in steps S810 and S811. Then, in step S813, as shown by a bidirectional dotted arrow 736e between ID4 which is the next code ID of the ID relation table 309b pointed to by ID1 in block 703b and the head code ID 742b in block 702b, in step S813 It is determined that ID3, which is an ID, is different from ID1, which is the head code ID.

Then, as indicated by an arrow 721a from code A to code B in block 701a, the code at the next code position becomes the processing target in step S814, and code B is extracted in step S815. As shown by a dotted arrow 755e between ID4 which is the next code ID of the ID relation table 310b pointed to by ID1 in block 703b and the ID range table 309b by code in block 702b, in step S816, the ID range table 309b by code is shown. In the code ID range including ID4 which is the next code ID, and in the example shown in the figure, as indicated by a dotted arrow 751e, the code C indicating the entry is temporarily stored. It is set in area 752e.

Then, as indicated by a bidirectional dotted arrow 753f, in step S817, it is determined that the code C set in the temporary storage area 752e and the code B extracted in step S815 do not match, resulting in a search failure. Therefore, the search failure is returned and the processing returns to the loop processing shown in FIG. 7B.

  Since ID1 which is the search start code ID is the search end code ID, the processing is ended by the determination in step S721 shown in FIG. 7B, and the processing returns to the loop processing shown in FIG. Since the search target code string is limited to the second code string block, the end of the entire search process is determined in step S604.

Although the embodiment for carrying out the present invention has been described in detail above, it is obvious to those skilled in the art that the embodiment of the present invention is not limited thereto and can be variously modified.
In addition, the code string search apparatus of the present invention has a storage unit that stores an index data management table, an ID range table for each code, and an ID relation table, and a program that causes the computer to execute the processes shown in FIGS. It is clear that it can be constructed.

Furthermore, the index data creation apparatus and method of the present invention can be realized by a program that causes a computer to execute the process of creating index data for code string search shown in FIGS. 4A to 5C and its equivalent. it is obvious. By these programs, means for creating the index data of the present invention is realized on the computer.
Therefore, the program and a computer-readable recording medium recording the program are included in the embodiment of the present invention. Furthermore, a data structure of index data for code string search of the present invention and a computer-readable recording medium on which index data having the data structure is recorded are also included in the embodiment of the present invention.

By adopting the code-specific ID range table and ID relationship table and the index data management table for managing them, which are new index data structures provided by the present invention described in detail above, the load of creating index data is reduced, The code string search can be performed efficiently.
Further, according to the present invention, since index data can be divided and stored in a plurality of storage areas, the size of the code string block can be reduced according to the hardware environment to be used even for a large amount of index data. It can also be made easier to access and maintain the index data.

10 character string 10a search object code string 11 code position pointer 20 suffix 20a in character position order suffix 30 in dictionary order 30 suffix array 40 search character string 40a search code string 50 compression suffix array 101 search object code string reading means 102 ID range table generation means 103 by code ID relation table generation means 104 Index data creation management means 105 Index data creation means 111 Search code string read means 112 ID range read means 113 by code ID relation read means 114 Code type search means 115 Code type Matching means 116 Code string search management means 117 Code string search means 301 Data processing device 302 Central processing device 303 Cache memory 304 Bus 305 Main storage device 306 External storage device 307 Communication device 308 Data storage device 309 ID range table 310 by code ID Table 311 Code type pointer 312 Code ID pointer 321 Index data management table 322 Index data management pointer 324 Index data storage area

Claims (16)

In a code string search device that searches a search target code string that is a search target using a search code string,
Provided for each code string block that is a partial code string obtained by dividing the search target code string into a plurality of parts,
A code-specific ID range table storing a code ID range, which is a range of code IDs that uniquely identify all codes located in the code string block, for each code of the same type;
Corresponding to the code ID, a next code ID that is a code ID of a code positioned next to the code related to the code ID in the code string block is stored, and the code related to the code ID is stored in the code string block. An ID relationship table that stores the code ID of the code located at the beginning of the code string block as the next code ID when located at the end;
A search execution unit that executes a search by the search code string with reference to an ID range table by code and an ID relation table provided for each code string block;
An index data management table storing a head code located at the head of the code string block for each code string block;
A search management unit that manages execution of search by the search execution unit;
With
The search execution unit
Search code string reading means for reading the search code string;
Code-specific ID range reading that reads the code ID range of the type of the first code constituting the search code string read by the search code string reading means from the code-specific ID range table corresponding to the specified code string block Means,
The next code ID stored corresponding to the code ID included in the code ID range of the first code type of the search code string read by the code-specific ID range reading means is the designated code string block The next code ID stored corresponding to the read next code ID is sequentially read from the ID relation table, and the next code ID is read from the head of the code string block. ID relationship reading means for determining whether the code ID is equal to the code;
When the next code ID read by the ID relation reading means is not equal to the code ID of the first code of the code string block, the code ID range of the code type is sequentially read from the code-specific ID range table, and the read Code type search means for searching for a code type including the next code ID in the code ID range by collating the code ID range of the code type and the next code ID;
A code type collating unit that collates the code type of the code read by the search code string reading unit and the code type searched by the code type searching unit;
The search management unit
While sequentially specifying the code string block from the top code string block to the search execution unit,
When the ID relation reading means determines that the read next code ID is equal to the code ID of the head code of the code string block, the head of the code string block located next to the code string block from the index data management table A code string search device, wherein the code execution block is designated as a code string block positioned next to the code string block by collating the head code with the code in the search code string. . The code string search device according to claim 1,
The code type search means is stored in the ID relation table in correspondence with the head code ID which is a code ID included in the code ID range of the code type of the first code which is the head code of the search code string. An index code which is a code type including a next code ID in the code ID range is searched, and the code type collating means is a code type of a second code positioned next to the first code in the search code string When the positions of the first code and the second code in the search code string are updated by the reading operation of the ID relation reading means, the code type The search means includes the next code ID stored in the ID relation table corresponding to the code ID of the updated first code at the position in the code ID range. Explore the pull cord, the code type collating means is for collating the index code and a second code code type of the updated of the position,
When the search management unit designates the next code string block located in the search execution unit, the ID relation reading unit has the read next code ID equal to the code ID of the head code of the code string block. Is read from the index data management table, the head code of the next code string block is read, and the head code and the next code that has been read are stored next to the first code. And the code string block positioned next is designated to the search execution unit when the head code and the code positioned next match.
A code string search device characterized by that. In the code string search device according to claim 2,
The ID relation table stores a code position indicating a position of a code related to the code ID in the search target code string, corresponding to the code ID,
The code type collating unit is configured such that the code type of the code after the first code read by the search code string reading unit and the index code searched by the code type searching unit are collated with the code at the end of the search code string If successful, the code position stored in the ID relation table corresponding to the code ID of the head code is output as a search result code position.
A code string search device characterized by that. In the code string search device according to claim 3,
The next code ID and code position stored in the ID relation table corresponding to the code ID are stored in order of code position for each code ID of the same type of code.
A code string search device characterized by that. The code string search device according to claim 4, wherein
Using all the code IDs included in the code ID range of the first code type of the search code string as the first code ID, the code type searching means searches the index code, and the code type checking means is the second code ID checking means. The code type of the code is collated with the index code,
A code string search device characterized by that. The code string search device according to claim 5, wherein
If the code type collating unit fails to collate the code type of the second code with the index code, the code type collating unit is stored in the same entry of the ID relation table with the next code ID included in the code ID range of the index code. The code position stored in the ID relation table corresponding to the head code ID is output as a search result code position.
A code string search device characterized by that. The code string search device according to claim 5, wherein
The search code string includes an arbitrary code that matches an arbitrary code,
The code type search means replaces the search for an index code including the next code ID read by the ID relation reading means with the arbitrary code as the first code in the code ID range, instead of the search code string. In the code ID range, a search is performed for an index code that includes the next code ID read by the ID relation reading unit using the code located next to the arbitrary code as the first code in the code ID range.
A code string search device characterized by that. A code string search device for searching a search target code string that is a search target using a search code string, wherein the code string is provided for each code string block that is a partial code string obtained by dividing the search target code string into a plurality of code strings. A code ID range table storing a code ID range, which is a range of code IDs for uniquely identifying all codes located in the block, for each code of the same type, and the code string block corresponding to the code ID The next code ID, which is the code ID of the code located next to the code related to the code ID, and when the code related to the code ID is located at the end of the code string block, the next code ID An ID relationship table for storing the code ID of the code located at the head of the code string block, and the code string block And index data management table that stores the start code at the head of the column blocks, and a search execution section, in the code string search method according to the code string search apparatus having a retrieval manager,
The search execution unit
A search code string reading step for reading the search code string;
Code-specific ID range reading that reads the code ID range of the type of the first code constituting the search code string read in the search code string read step from the code-specific ID range table corresponding to the specified code string block Steps,
The next code ID stored corresponding to the code ID included in the code ID range of the first code type of the search code string read in the code-specific ID range reading step is the designated code string block The next code ID stored corresponding to the read next code ID is sequentially read from the ID relation table, and the next code ID is read from the head of the code string block. An ID relationship reading step for determining whether the code ID is equal to the code ID;
When the next code ID read in the ID relation reading step is not equal to the code ID of the first code of the code string block, the code ID range of the code type is sequentially read from the code-specific ID range table, and the read A code type search step for searching for a code type including the next code ID in the code ID range by checking the code ID range of the code type and the next code ID;
A code type collating step for collating the code type of the code read in the search code string reading step with the code type searched in the code type searching step;
Run
The search management unit
A search start position specifying step of sequentially specifying the code string block from the top code string block in the search execution unit;
In the ID relation reading step, when it is determined that the read next code ID is equal to the code ID of the head code of the code string block, the code string block located next to the code string block from the index data management table A next code string designating step for designating a code string block positioned next to the code string block to the search execution unit by comparing the head code with a code in the search code string;
The code string search method characterized by performing this. The code string search method according to claim 8, wherein
The code type search step is stored in the ID relation table in correspondence with a head code ID that is a code ID included in a code ID range of a code type of a first code that is a head code of the search code string. An index code which is a code type including a next code ID in the code ID range is searched, and the code type collating step includes a code type of a second code positioned next to the first code in the search code string And the index code, and thereafter, when the positions of the first code and the second code in the search code string are updated by the reading operation of the ID relation reading step, the code type In the search step, the next code ID stored in the ID relation table corresponding to the code ID of the updated first code at the position is stored. It searches the index code comprising a code ID range, in the code type matching step is intended to match the index code and a second code code type of the updated of the position,
The next code string specifying step includes:
In the ID relation reading step, when it is determined that the read next code ID is equal to the code ID of the head code of the code string block, the head of the code string block located next from the index data management table A code is read, and the head code and the code next to the first code stored corresponding to the read next code are collated, and if both match, the code string block located next To the search execution unit,
A code string search method characterized by the above. The code string search method according to claim 9,
The ID relation table stores a code position indicating a position of a code related to the code ID in the search target code string, corresponding to the code ID,
In the code type collating step, the code type of the code after the first code read in the search code string reading step and the index code searched in the code type searching step are matched with the code at the end of the search code string. If successful, the code position stored in the ID relation table corresponding to the code ID of the head code is output as a search result code position.
A code string search method characterized by the above. The code string search method according to claim 10,
Using all the code IDs included in the code ID range of the first code type of the search code string as the first code ID, the code type searching step searches the index code, and the code type collating step is the second code type checking step. The code type of the code is collated with the index code,
A code string search method characterized by the above. A code string search device for searching a search target code string that is a search target using a search code string, wherein the code string is provided for each code string block that is a partial code string obtained by dividing the search target code string into a plurality of code strings. A code ID range table storing a code ID range, which is a range of code IDs for uniquely identifying all codes located in the block, for each code of the same type, and the code string block corresponding to the code ID The next code ID, which is the code ID of the code located next to the code related to the code ID, and when the code related to the code ID is located at the end of the code string block, the next code ID An ID relation table for storing the code ID of the code located at the head of the code string block, and the code string for each code string block; And index data management table that stores the start code at the head of the column blocks, and a search execution section, in the code string search program for realizing the functions of the code string search apparatus having a retrieval management unit to the computer,
On the computer,
As a function of the search execution unit,
A search code string reading function for reading the search code string;
Code-specific ID range reading that reads out the code ID range of the type of the first code constituting the search code string read by the search code string read function from the code-specific ID range table corresponding to the specified code string block function,
The next code ID stored corresponding to the code ID included in the code ID range of the first code type of the search code string read by the code-specific ID range reading function is the designated code string block The next code ID stored corresponding to the read next code ID is sequentially read from the ID relation table, and the next code ID is read from the head of the code string block. ID relation reading function for determining whether the code ID is equal to the code ID,
When the next code ID read by the ID relation reading function is not equal to the code ID of the head code of the code string block, the code ID range of the code type is sequentially read from the code-specific ID range table, and the read A code type search function for searching for a code type including the next code ID in the code ID range by comparing the code ID range of the code type and the next code ID,
A code type checking function for checking the code type of the code read by the search code string reading function and the code type searched by the code type search function;
Realized,
As a function of the search management unit,
A search start position specifying function for sequentially specifying the code string block from the top code string block in the search execution unit;
When it is determined by the ID relation reading function that the read next code ID is equal to the code ID of the first code of the code string block, the code string block located next to the code string block from the index data management table A next code string designating function for designating a code string block positioned next to the code string block to the search execution unit by comparing the head code with a code in the search code string,
A code string search program characterized by realizing the above. In the code string search program according to claim 12,
The code type search function is stored in the ID relation table in correspondence with a head code ID that is a code ID included in a code ID range of a code type of a first code that is a head code of the search code string. An index code which is a code type including a next code ID in the code ID range is searched, and the code type collating function is configured such that the code type of the second code positioned next to the first code in the search code string And the index code, and thereafter, when the positions of the first code and the second code in the search code string are updated by the read operation of the ID-related read function, the code type The search function includes, in its code ID range, the next code ID stored in the ID relation table corresponding to the code ID of the updated first code at the position. Explore the pull cord, the code type matching function includes a function of checking the index code and a second code code type of the updated of the position,
The next code string specifying function is:
When the ID related read function determines that the read next code ID is equal to the code ID of the head code of the code string block, the head of the code string block located next from the index data management table A code is read, and the head code and the code next to the first code stored corresponding to the read next code are collated, and if both match, the code string block located next A code string search program comprising a function of designating the search execution unit as In the code string search program according to claim 13,
The ID relation table stores a code position indicating a position of a code related to the code ID in the search target code string, corresponding to the code ID,
The code type collating function is such that the code type of the code after the first code read by the search code string reading function and the index code searched by the code type search function are codes at the end of the search code string If successful, the function of outputting the code position stored in the ID relation table corresponding to the code ID of the head code as a search result code position,
A code string search program characterized by that. In the code string search program according to claim 14,
The code type search function searches the index code using all the code IDs included in the code ID range of the code type of the head code of the search code string as the head code ID, and the code type collation function Including a function of collating the code type of the code with the index code,
A code string search program characterized by that.   The computer-readable recording medium which recorded the code sequence search program of any one of Claims 12-15.

Images