CN100511229C - Domain name information storage and inquiring method and system - Google Patents

Abstract

A method and system for storing and querying domain name character strings, comprising: comparing the domain name character strings to be stored, and storing the part with the same prefix of the domain name character strings to be stored as a common node; Different parts of the stored domain name strings are inserted and stored as child nodes of the common node; for two domain name strings that do not match completely, they are inserted and stored as sibling nodes. When querying, A. compare and judge the character string in the node with the character string to be queried; B. If the two match completely, take the unmatched part of the character string to be queried and the character string in the node as the new character string to be queried, and take The child node of the string in the current node is used as the new current node, and returns A; C. If the two do not match completely, take the sibling node of the current node as the new current node, and perform the next round of comparison with the string to be queried and Judgment, return to step B. This method improves the query speed of domain name class strings.

Description

A storage and query method and system for domain name information

technical field

The invention relates to the field of communication technology, in particular to a storage and fast query method for domain name information and a storage and query system for domain name information.

Background technique

With the rapid development of computer technology, the amount of information is increasing exponentially. Such a large amount of information has brought many difficulties to finding and storing information. We need an effective way to find data. The purpose of searching is to find a specific value from some data. The resulting various search methods are all for the pursuit of higher efficiency and more convenient operation. The same is true for the domain name search. For example, in a specific network application, if you need to know whether a certain domain name has been saved, if it has been saved, you need to redirect the sent data packets. In this case, it is necessary to quickly know whether a domain name is stored. If a large amount of time is spent on the query, the performance of the network will be greatly reduced, and many network problems may occur.

Existing related retrieval technologies mainly include prefix tree and BSD radix tree.

A BSD radix tree is a data structure designed for looking up IP addresses. The storage structure of the nodes of the BSD radix tree is shown in Figure 1. The internal nodes and leaf nodes all use the radix_node structure, but the definitions of a few fields are different. First, check the fields in the radix_node structure through internal nodes. This structure mainly stores pointers to child nodes and pointers to parent nodes, as well as position information of bits to be detected. The search process of the BSDradix tree is divided into three steps: the first step, as shown in Figure 2, is to find the leaf node, assuming that a certain route needs to be searched in the radix tree now. Starting at the top of the tree, tests are performed against bits specified by internal nodes along the way. First test the test bit of the root node, if the test result of the root node is 1, then enter the left subtree, if the test result is 0, then enter the right subtree. Continue to judge according to the above method, and you will encounter a node with a negative value in the field to be tested, that is, a leaf node, so the search operation will stop here. The second step is identification: if the leaf node found in the first step does not meet the matching condition with the search key, it is necessary to traverse the duplicate key linked list of the leaf node. Since the leaf node in the duplicate key list is exactly the same as the key value (that is, the IP address) of the leaf node found in the first step, but the mask is gradually shortened, there may be a network match in the duplicate key list possible. The process of repeated key processing is shown in Figure 3. The third step, backtracking: so far, only using the IP address as the lookup key to find a certain leaf node in the radix tree according to the bit test position indicated by the internal node, and performing duplicate key processing, but still no matching leaf is found node. This does not rule out that there are other leaf nodes that may meet the network matching conditions in the radix tree, so it is necessary to trace back to the top of the tree along the internal node path at the time of arrival to seek the possibility of network matching. The backtracking process is shown in Figure 4. A series of internal nodes are passed through on the way back. For each internal node, it will be judged whether it has a mask linked list. The mask linked list is represented by a thick solid line in Figure 4. Internal nodes without a mask list will not be considered and passed directly. If there is a mask linked list attached to an internal node, it means that there may be a possibility of network matching in its subtree, and it is necessary to stop and make a judgment before deciding whether to continue backtracking.

The BSD radix tree is a search tree based on key values represented in binary, especially suitable for processing very long, variable-length key values. Of course, a string can also be regarded as a binary key value, but there are only dozens of possible values for each character in the string (a-z, A-Z, etc.), compared to each character of a pure binary key value The case where 256 sections can be selected is much smaller, but this method also treats the string as a binary stream for query, so querying the string with this method cannot well reflect the advantage of speed.

The prefix tree is mostly used in data mining, and its storage method is shown in Figure 5. If the prefix tree limits the character set of its nodes to 26 English letters, it can be regarded as a tree structure with at most 26 branches. The prefix tree can also provide a relatively fast query method. However, the structure of the prefix tree saves a lot of redundant string information, which leads to unnecessary backtracking when looking up domain names. For example: to search for "Chinese" in the prefix tree shown in Figure 4, first search from the root node, match the word "中", and enter the "Chinese" subtree. Then compare "China" from the beginning to see if it matches, causing backtracking. Then it entered the "Chinese" node and started matching again. A lot of time was wasted on unnecessary backtracking. When this method is used to store domain name strings, it wastes storage space, and because of the deep tree structure, the search speed is slow, and this technique also cannot compress the storage capacity of data.

Contents of the invention

The technical problem to be solved by the present invention is to provide a storage method suitable for quickly searching domain name strings;

Another problem to be solved by the present invention is to provide a domain name string query method corresponding to the above storage method, which can quickly and effectively determine whether a certain domain name string has been stored.

The invention also provides a domain name information storage and query system.

The technical scheme that the present invention adopts for solving the problems of the technologies described above is:

A method for storing domain name character strings, the method comprising: comparing the domain name character strings to be stored, storing the same prefix part of the domain name character strings to be stored as a common node; Different parts of the stored domain name strings are inserted and stored as child nodes of the common node; for two domain name strings that do not match completely, they are inserted and stored as sibling nodes.

The method, wherein: an empty node is inserted behind the node that has stored a complete character string.

The method, wherein: the method includes the following specific steps:

A. Compare and judge the string to be stored with the string in the node. When the string to be stored completely matches the string in the current node, the return result is true; when the string to be stored does not match the string in the current node at all When , go to step B; when the character string to be stored matches part of the character string in the current node, go to step C;

B. Determine whether the current node has a sibling node, if the current node has a sibling node, then use the sibling node as the new current node, and return to step A; if the current node has no sibling node, then use the node to be inserted as the sibling of the current node node insertion;

C. Divide the incompletely matched character string to be stored and/or the character string in the current node into the same prefix and the unmatched part, retain the same prefix as the current node, and insert the unmatched part as the child node of the current node.

The method, wherein: in the step C, when the character string to be stored is completely matched and the character string in the current node is partially matched, the following specific processing is included: the character string in the current node is divided into the first identical part and the first different part. Part, keep the first same part as the current node, insert and store the first different part as the child node of the current node, and insert an empty node behind the first different part node.

The method, wherein: in the step C, when the character strings in the nodes are completely matched and the character strings to be stored are partially matched, it includes the following specific steps:

C1. Dividing the character string to be stored into a second identical part and a second different part;

C2. Determine whether the current node has child nodes;

C3. If there is a child node, use the second different part as a new character string to be stored, compare the child node as a new character string in the current node, and repeat step A; otherwise keep the character string in the node, and use the second character string The second different part is inserted and stored as a child node of the current node, and an empty node is inserted behind the second different part node.

The method, wherein: in the step C, when the character string in the node is partially matched and the character string to be stored is partially matched, the following processing is included: the character string to be stored is divided into the same part and the second different part; Divide the string into the same part and the first different part; keep the same part as the current node, insert and store the first different part as a child node of the current node, insert and store the second different part as its sibling node, or insert and store the second different part It is inserted and stored as a child node of the current node, and the first different part is inserted and stored as its sibling node.

A method for querying domain name character strings, said method comprising the steps of:

A. Compare the character string in the node with the character string to be queried, and determine whether the character string in the node exactly matches the character string to be queried;

B. If the character string in the node matches completely, take the unmatched part of the character string to be queried and the character string in the node as the new character string to be queried, and take the child node of the character string in the current node as the new current node, and return to step A;

C. If the character string in the node does not exactly match the character string to be queried, take the sibling node of the current node as the new character string in the current node, and return to step A.

The query method, wherein: the step A includes the following specific steps:

A1. Determine whether the current node is valid, if the current node is invalid, return true directly, and if it is valid, enter step A2;

A2. Compare the character string to be queried with the character string in the node, and determine whether the character string in the node completely matches the character string to be queried.

The query method, wherein: the step C includes the following specific steps:

C1. If the string in the node does not exactly match the string to be queried, take the sibling node of the current node as the new string in the current node;

C2. Judging whether the new current node is valid, if the new current node is invalid, directly return false, and if valid, return to step A2.

A domain name class information storage query system, comprising a plug-in module, a DNS-Tree storage module, and a memory management module connected to the plug-in module and the DNS-Tree storage module respectively, the memory management module is used to compare domain name class string, and allocate and manage the node memory of the DNS-Tree storage module;

Also includes a query processing module connected with the DNS-Tree storage module, the query processing module is used to compare and judge the character string to be queried with the character string in the DNS-Tree storage module to obtain the character string to be queried Is the result already in the DNS-Tree storage module.

The beneficial effects of the present invention are: after fully considering and utilizing the characteristics of domain name strings, the present invention adopts the above storage method for domain name strings. This method not only effectively reduces the demand for memory, but also due to this The tree structure of the domain name service tree (DNSTree) established by the storage method is not deep, and the tree structure is balanced, which reduces the time complexity and space complexity when querying and retrieving. Therefore, the query method of the present invention can quickly and effectively judge the domain name category. Whether the string has been stored, speeds up the query speed and improves the retrieval efficiency.

Description of drawings

Figure 1 is a schematic diagram of the node storage structure of the BSD radix tree;

Figure 2 is a schematic diagram of the process of testing the root node of the BSD radix tree;

Figure 3 is a diagram of the BSD radix tree duplicate key processing process;

Figure 4 is a schematic diagram of the BSD radix tree backtracking process;

Fig. 5 is a schematic diagram of a prefix tree storage method;

Fig. 6 is the tree structure diagram of DNSTree of the present invention;

Fig. 7 is a flowchart of the DNSTree storage method of the present invention;

Fig. 8 is a flowchart of DNSTree query algorithm of the present invention;

FIG. 9 is a schematic diagram of a storage query system for domain names according to the present invention.

Detailed ways

Below according to accompanying drawing and embodiment the present invention will be described in further detail:

Because the domain name string has its particularity, that is, the domain name will not be too long, and most of the domain names are meaningful and easy to remember strings, so often you can find many identical prefixes such as: www, ftp, etc., we will have the above Character strings similar to domain name strings are called domain name-like strings. According to these two characteristics, the present invention improves the domain name class storage and query methods so as to speed up the search of domain name class character strings. The following uses domain name strings as an example to illustrate, for example, the following 6 domain name strings are given:

www.baidu.com

www.google.com,

www.goobersite.com

www.google.com.cn

www.yahoo.com.cn

www.yahoo.com

The storage method of the present invention is as follows: compare the domain name character strings to be stored, store the same prefix part of each domain name character string with a node, and insert and store different parts as sub-nodes, completely different characters Strings are inserted and stored as sibling nodes. For example, www.baidu.com and www.google.com only have www. as the same prefix, then www. can be used as a public node, and baidu.com and google.com are inserted as two child nodes of the public node www.. When www.yahoo.com is compared with www.baidu.com as the character string to be stored, only www. has the same prefix. Similarly, www. is used as a public node, and different parts of yahoo.com are inserted as sibling nodes of baidu.com. By analogy, the DNSTree tree structure shown in Figure 6 is obtained. This storage method will save a lot of memory when storing a large number of strings with the same prefix. Here is a simplified representation of Figure 6:

www.

+baidu.com

+goo

+bersite.com

+gle.com

+.cn

+ ""

+yahoo.com

+.cn

+ ""

""

The "" in the figure represents an empty node, which is used to indicate that the previous string is already a complete string, and there is no need to add any characters later. For example, when the two strings www.google.com and www.google.com.cn are inserted into the tree, there will be a shape like www.google.com

+.cn

+ ""

Adding an empty node "" after www.google.com means that www.google.com is a complete string, otherwise it is difficult to distinguish whether there is a string of www.google.com without "".

The method for storing domain name strings of the present invention will be specifically described below according to the flow chart of the DNSTree storage method shown in FIG. 7 . First, the abbreviations and definitions in the flowchart are explained:

INN_STR: In-node character string, representing a character string saved in a node.

PPI_STR: the string matching part in the node, which means that two strings are compared with the same prefix part of the string in the node, for example, abcde (string in the node) is compared with abckef, and its PPI_STR is abc;

BPI_STR: The non-matching part of the string in the node, indicating that the two strings are compared to the different parts of the string in the node. For example, abcde (string in the node) is compared with abckef, and its BPI_STR is de;

WTI_STR: String to be inserted, indicating a string to be inserted into DNSTree;

PPW_STR: The matching part of the string to be inserted, indicating that the two strings are compared to the same prefix part of the string to be inserted. For example, abcde is compared with abckef (string to be inserted), and its PPW_STR is abc;

BPW_STR: The unmatched part of the string to be inserted, which means the different part of the string to be inserted compared with the two strings. For example: abcde is compared with abckef (string to be inserted), and its BPW_STR is kef.

The meaning of the above exact match means that a certain string can be the prefix of another string. For example: INN_STR is completely matched, which means that INN_STR is compared with WTI_STR, and INN_STR can be used as a prefix of WTI_STR, for example: abcd(INN_STR) and abcdefg(WTI_STR). Another example: WTI_STR is completely matched, which means that INN_STR is compared with WTI_STR, and WTI_STR can be used as the prefix of INN_STR, for example: abcd(WTI_STR) and abcdefg(INN_STR).

Partial match means that two strings have part of the same prefix but not a complete match, for example: abcke and abkei. Among them: INN_STR partly matches, which means that INN_STR is compared with WTI_STR. INN_STR and WTI_STR have the same prefix, for example: abcde (INN_STR) and abeiek (WTI_STR) have the same prefix ab, but there must be different parts after INN_STR; WTI_STR part Match, meaning that INN_STR is compared with WTI_STR, and INN_STR and WTI_STR have the same prefix. For example: abcde(WTI_STR) and abeiek(INN_STR) have the same prefix ab, but there must be different parts after WTI_STR.

No match at all, meaning that the two strings do not have the same prefix at all.

According to the above definition, the steps of the method for storing domain name strings in the present invention are as follows:

1. Comparing WTI_STR with INN_STR, both WTI_STR and INN_STR completely match and go to step 2, completely mismatch and go to step 3, and partial match go to step 4;

2. The return result is true;

3. Determine whether the current node has a sibling node. If there is a sibling node as the current node, enter 1. If not, it is inserted as a sibling node.

4. Partial matching is divided into the following three sub-cases:

1).WTI_STR is fully matched, and INN_STR is partially matched:

a. Divide INN_STR into PPI_STR and BPI_STR,

b. Reserve PPI_STR, insert BPI_STR into the DNSTree tree as a child node of the current node, and insert an empty node after the BPI_STR node.

2).INN_STR matches completely, and WTI_STR partially matches

a. Determine whether the INN_STR node has child nodes

b. If there is a child node, then BPW_STR will be the new WTI_STR, and the child node of INN_STR will be the new current node, and then turn to 1.

c. If there is no child node, the PPI_STR node is reserved, and BPW_STR is inserted as a child node of the current node, and then an empty node is inserted after the inserted child node.

3). Partial match of .INN_STR and partial match of WTI_STR.

a. Divide WTI_STR into PPW_STR and BPW_STR;

b. Reserve PPI_STR as the current node, insert BPI_STR as the child node of the current node, and insert BPW_STR as the sibling node of the BPI_STR node.

It can be seen that since the same prefix part of the domain name is stored in a common node, the DNSTree tree structure established according to this method is not deep, and the tree structure is balanced, which will undoubtedly reduce the time complexity of query retrieval in the process of finding domain names And space complexity, improve the query speed; at the same time, this storage method effectively reduces the memory requirement.

For this DNSTree tree structure, its corresponding search process is shown in Figure 8, described as follows:

Related concepts:

INN_STR: In-node character string, representing the character string stored in the node.

WTI_STR: with a comparison string, indicating that a certain string needs to be queried whether it already exists.

1. Determine whether the current node is valid, return true directly if invalid, and enter step 2 if valid;

2. Determine whether INN_STR matches WTC_STR completely, if they match, go to step 3, if not, go to step 4;

3. Take the unmatched part of WTC_STR as the new WTC_STR, take the child nodes of the current node as the new current node, and return to step 1;

4. Take the sibling node of the current node as the new current node;

5. Determine whether the new current node is valid, if invalid, return false, if valid, return to step 2, determine whether the new current node matches WTC_STR completely, and enter the next cycle.

The system for storing query domain name character strings according to the present invention is shown in FIG. 9 . It includes four main modules: Insertion module: The main function of the insertion module is to insert strings into specific nodes of the DNS-Tree tree according to the DNS-Tree tree structure. This module is mainly used when DNS-Tree is initialized, and this part is used to complete the initialization of the tree. Memory management module: including the comparator and the control part, the memory management module mainly manages the allocation and management of node memory in the DNS-Tree. Because the domain name character strings are not long, the required memory belongs to the small block memory, so the memory management module adopts the method of the memory pool in the prior art to manage the small block memory. Query processing module: the function of the query module is to check whether the character string to be queried has been saved in the DNS-Tree. Process the string to be queried, compare and judge with the string in the DNS-Tree, and obtain the result of whether the string to be queried is already in the DNS-Tree. DNS-Tree is a storage module, that is, a memory area.

It can be understood that those skilled in the art can make equivalent replacements or changes according to the technical solutions and inventive concepts of the present invention, and all these changes or replacements should belong to the protection scope of the appended claims of the present invention.

Claims (10)

1, a kind of storage means of domain name kind string, described method comprises: will compare between the domain name kind string to be stored, described domain name kind string same prefix to be stored is partly deposited with a node, as common node; Domain name kind string different piece to be stored is deposited as the child node insertion of this common node; For complete unmatched two domain name kind string, then insert and deposit as the brotgher of node.

2, method according to claim 1 is characterized in that: insert an empty node in the node back of depositing a complete character string.

3, method according to claim 2 is characterized in that: described method comprises following concrete steps:

A, character string to be stored and intranodal character string are compared judgement, when character string was mated fully in character string to be stored and the present node, return results was true; When character string does not match fully in character string to be stored and the present node, enter step B; When character string is partly mated in character string to be stored and the present node, enter step C;

B, judge whether present node has the brotgher of node, if present node has the brotgher of node, then the described brotgher of node as new present node, return steps A; If present node does not have the brotgher of node, then will be inserted into node and insert as the brotgher of node of present node;

Character string is divided into same prefix and the part that do not match in C, the character string to be stored that will not exclusively mate and/or the present node, keeps same prefix as present node, and the part that do not match is inserted as the child node of present node.

4, method according to claim 3, it is characterized in that: work as character string to be stored among the described step C and mate fully, and when character string is partly mated in the present node, comprise following concrete processing: character string in the present node is divided into the different portions with first of first identical portions, keep first identical portions as present node, the first different portions are deposited as the child node insertion of present node, and inserted node in the first different portions node back.

5, method according to claim 3 is characterized in that: mate fully when the intranodal character string among the described step C, and character string to be stored is when partly mating, it comprises following concrete steps:

C1, character string to be stored is divided into the different portions with second of second identical portions;

C2, judge whether present node has child node;

C3, if child node is arranged, as new character string to be stored, child node compares as character string in the new present node, repeating step A with the described second different portions; Otherwise keep the intranodal character string, the described second different portions are inserted as the child node of present node deposit, and inserted node in the second different portions node back.

6, method according to claim 3 is characterized in that: partly mate when the intranodal character string among the described step C, and character string to be stored comprises following processing: character string to be stored is divided into the different portions with second of identical portions when partly mating; The intranodal character string is divided into the different portions with first of identical portions; Keep identical portions as present node, the first different portions are deposited as the child node insertion of present node, the second different portions are deposited as its brotgher of node insertion, or the second different portions are deposited as the child node insertion of present node, the first different portions are inserted as its brotgher of node deposit.

7, a kind of querying method of domain name kind string, described method comprises the steps:

A, intranodal character string and character string to be checked are compared, whether character string mates fully with character string to be checked in the decision node;

B, if the intranodal character string is mated fully, get character string to be checked and intranodal character string and do not match part as new character string to be checked, the child node of getting the interior character string of present node is returned steps A as new present node;

C, if intranodal character string and character string to be checked are not exclusively mated, the brotgher of node of then getting present node is returned steps A as character string in the new present node.

8, querying method according to claim 7 is characterized in that: described steps A comprises following concrete steps:

A1, judge whether present node is effective, true if present node directly returns when invalid, enter steps A 2 in the time of effectively;

A2, character string to be checked and intranodal character string are compared, whether character string mates fully with character string to be checked in the decision node.

9, querying method according to claim 8 is characterized in that: described step C comprises following concrete steps:

C1, if when intranodal character string and character string to be checked are not exclusively mated, the brotgher of node of getting present node is as character string in the new present node;

C2, judge whether new present node is effective,, return steps A 2 in the time of effectively if new present node directly returns vacation when invalid.

10, a kind of domain name kind information stores inquiry system, it is characterized in that: comprise an insert module, one DNS-Tree memory module, and the memory management module that is connected with the DNS-Tree memory module with described insert module respectively, described memory management module is used for the comparison domain name kind string, and the node memory of DNS-Tree memory module is distributed and manages;

Also comprise a query processing module that is connected with described DNS-Tree memory module, whether described query processing module is used for character string with character string to be checked and DNS-Tree memory module and compares and judge, draw character string to be checked result in the DNS-Tree memory module.

Images