JP2014134901A - Updating method, update program and collation processing device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To fasten collation processing of a query using an automaton.SOLUTION: When updating an automaton A for each portion required for collation step by step from an initial automaton A0, a collation processing device 100 counts the cumulative number of times of detection each time a path satisfying a condition of a query Q is detected. In the case where the path satisfying the condition of the query Q is detected, the collation processing device 100 newly adds a path collation state specifying the detected path to the automaton A. In the case where there is no space in the automaton A, the collation processing device 100 cancels a path collation state for specifying the path with the minimum number of times of detection from the automaton A and newly adds a path collation state to the automaton A.

Description

  The present invention relates to an update method, an update program, and a verification processing device.

  Conventionally, there is a technique for matching a query including a path keyword to an input stream using an automaton. The automaton is updated step by step from the initial automaton for each part required for verification. In the automaton update, the state defined in the automaton may be deleted in order to suppress the use amount of the storage area for storing the automaton.

  As a related technique, for example, an absolute path and a scope path of a target path and a predicate are extracted for each of a plurality of branch XPath expressions, and a partially equal node or a link between nodes is shared as a shareable part. There is something to share. Further, for example, a node or a link between nodes is shared to construct one shared index from a plurality of branch XPath expressions, and the branch XPath expression is based on a reference counter set for each node of the shared index. There is a technology to register and delete. In addition, for example, the condition that the element specified by the search expression does not appear is obtained from the structure information of the structured document, and when the interruption condition is satisfied, the state transition of the search automaton is deleted and all the valid state transitions are deleted. There is a technique for ending the analysis when there is no more.

JP 2007-249724 A International Publication No. 2006/080469

  However, in the above-described conventional technology, the amount of update processing that is performed when transitioning to the same state as the state deleted from the automaton and re-creating the same state as the deleted state and adding to the automaton is increased. The processing time required for query matching processing increases.

  In one aspect, an object of the present invention is to speed up a query matching process using an automaton.

  According to one aspect of the present invention, a computer that performs matching of a query including a keyword and a path condition corresponding to the keyword with respect to an input stream hierarchized by tags using an automaton, Each time a path that satisfies the condition is detected, the number of detections for each path that satisfies the condition is counted, and an initial state, a start state that indicates a start tag symbol, and an end state that indicates an end tag symbol are defined. An update method for updating the automaton based on the number of detections for each path satisfying the counted condition when adding a new path matching state indicating a path satisfying the condition to the automaton in which a plurality of path matching states indicating An update program and a verification processing device are proposed.

  According to one aspect of the present invention, it is possible to increase the speed of query matching processing using an automaton.

FIG. 1 is an explanatory diagram showing an example of automaton update according to the present embodiment. FIG. 2 is an explanatory diagram showing an example of collation between the input stream S and the query Q. FIG. 3 is an explanatory diagram illustrating an example of conversion of the input stream S. FIG. 4 is an explanatory diagram showing the path of the input stream S. FIG. 5 is an explanatory diagram showing an example of the path ID management table. FIG. 6 is an explanatory diagram showing an example of the frequency management table. FIG. 7 is an explanatory diagram showing a construction example of the initial automaton A0. FIG. 8 is an explanatory diagram illustrating an example of a node structure. FIG. 9 is an explanatory diagram showing an example of the node structure N in each state in the initial automaton A0. FIG. 10 is an explanatory diagram (part 1) of the first operation example of the verification processing device 100. FIG. 11 is an explanatory diagram (part 2) of the first operation example of the collation processing device 100. FIG. 12 is an explanatory diagram (part 3) illustrating a first operation example of the collation processing device 100. FIG. 13 is an explanatory diagram (part 4) illustrating a first operation example of the collation processing device 100. FIG. 14 is an explanatory diagram (No. 5) illustrating a first operation example of the matching processing device 100. FIG. 15 is an explanatory diagram (No. 6) illustrating a first operation example of the matching processing device 100. FIG. 16 is an explanatory diagram (No. 7) illustrating a first operation example of the matching processing device 100. FIG. 17 is an explanatory diagram (No. 8) illustrating a first operation example of the matching processing device 100. FIG. 18 is an explanatory diagram (No. 9) illustrating a first operation example of the matching processing device 100. FIG. 19 is an explanatory diagram (No. 10) illustrating a first operation example of the matching processing device 100. FIG. 20 is an explanatory diagram (part 11) illustrating the first operation example of the matching processing device 100. FIG. 21 is an explanatory diagram (No. 12) illustrating a first operation example of the matching processing device 100. FIG. 22 is an explanatory diagram (No. 13) illustrating a first operation example of the matching processing device 100. FIG. 23 is an explanatory diagram (No. 14) illustrating a first operation example of the matching processing device 100. FIG. 24 is an explanatory diagram (No. 15) illustrating a first operation example of the matching processing device 100. FIG. 25 is an explanatory diagram (No. 16) illustrating a first operation example of the matching processing device 100. FIG. 26 is an explanatory diagram (No. 17) illustrating a first operation example of the matching processing device 100. FIG. 27 is an explanatory diagram (No. 18) illustrating a first operation example of the matching processing device 100. FIG. 28 is an explanatory diagram (No. 19) illustrating a first operation example of the matching processing device 100. FIG. 29 is an explanatory diagram (No. 20) illustrating a first operation example of the matching processing device 100. FIG. 30 is an explanatory diagram (No. 21) illustrating a first operation example of the matching processing device 100. FIG. 31 is an explanatory diagram (part 1) illustrating a second operation example of the matching processing device 100. FIG. 32 is an explanatory diagram (part 2) of the second operation example of the collation processing device 100. FIG. 33 is an explanatory diagram (part 3) of the second operation example of the matching processing device 100. FIG. 34 is an explanatory diagram (part 4) of the second operation example of the matching processing device 100. FIG. 35 is an explanatory diagram (No. 5) illustrating a second operation example of the matching processing device 100. FIG. 36 is an explanatory diagram (No. 6) illustrating a second operation example of the matching processing device 100. FIG. 37 is an explanatory diagram (No. 1) illustrating a third operation example of the matching processing device 100. FIG. 38 is an explanatory diagram (part 2) of the third operation example of the collation processing device 100. FIG. 39 is an explanatory diagram (part 3) of the third operation example of the collation processing device 100. FIG. 40 is an explanatory diagram (part 4) of the third operation example of the collation processing device 100. FIG. 41 is an explanatory diagram (No. 5) illustrating a third operation example of the matching processing device 100. FIG. 42 is a block diagram illustrating a hardware configuration example of the collation processing device 100. FIG. 43 is a block diagram illustrating a functional configuration example of the collation processing device 100. FIG. 44 is a flowchart illustrating an example of a processing procedure of update processing of the verification processing device 100. FIG. 45 is a flowchart showing an example of the processing procedure of the initial automaton construction process (step S4403) shown in FIG. FIG. 46 is a flowchart illustrating an example of a processing procedure of the first scanning process (step S4409) illustrated in FIG. FIG. 47 is a flowchart illustrating an example of a processing procedure of the first update processing (step S4606) illustrated in FIG. FIG. 48 is a flowchart illustrating an example of a processing procedure of the deletion process (step S4702) illustrated in FIG. FIG. 49 is a flowchart illustrating an example of a processing procedure of the second update process (step S4607) illustrated in FIG. FIG. 50 is a flowchart illustrating an example of a processing procedure of the cumulative number updating process (step S4609) illustrated in FIG. FIG. 51 is a flowchart showing an example of the processing procedure of the second scanning process (step S4410) shown in FIG. FIG. 52 is a flowchart showing an example of the processing procedure of the third scanning process (step S4411) shown in FIG.

  Exemplary embodiments of an update method, an update program, and a verification processing device according to the present invention will be described below in detail with reference to the accompanying drawings. In the present embodiment, “A” is used as a code that collectively refers to automata, but “A0”, “A1”, “A2”... “An” are added in order to specify the update state. There is. “A0” is a code indicating the initial automaton, “A1” is a code indicating the automaton after the first update, “A2” is a code indicating the automaton after the second update, and “An” Is a code indicating the automaton after the nth update.

<Example of automaton update>
FIG. 1 is an explanatory diagram showing an example of automaton update according to the present embodiment. As shown in FIG. 1, the matching processing device 100 is a computer that performs query Q matching on an input stream S using an automaton A. When collation processing apparatus 100 performs collation of query Q, if various states used for collation of query Q are not defined in automaton A, various states used for collation of query Q are newly added to automaton A. Thus, the automaton A is updated.

  Here, the input stream S is a data string that is hierarchized by tags, and is a data string that is received from the computer that is the source G via the network 101. The input stream S is, for example, XML (Extensible Markup Language) data or HTML (HyperText Markup Language) data. In the following description, XML data will be described as an example.

  A tag is information indicating a position where a set of elements exists, and is, for example, a start tag or an end tag. The position is, for example, a hierarchy in the input stream S. The start tag is information indicating the start position of a set of elements, and in the example of FIG. 1, is a start tag <news>, a start tag <name>, or the like. The end tag is information indicating the end position of the set of elements. In the example of FIG. 1, the end tag is an end tag </ news>, an end tag </ name>, or the like. An element is a character string, a start tag, or an end tag included between a start tag and an end tag.

  The query Q is information including, for example, a keyword and a path condition corresponding to the keyword. The query Q is stored in the query DB 102 in the example of FIG. The keyword is a character string that is collated with the character string in the input stream S, and is the character string “Bob” in the example of FIG. The path is, for example, a path from the top layer of the input stream S to a layer indicated by an arbitrary tag. In the following description, the path is expressed in a format in which the character strings in the tags of each tag on the route from the top layer to the layer indicated by an arbitrary tag are connected by “/”. In the example of FIG. 1, the path of the start tag <news> is a character string in the tag of each tag on the route from the 0th hierarchy indicated by the root that is the highest hierarchy to the 1st hierarchy indicated by the start tag <news>. “/ News” connected with “/”. Similarly, the path of the start tag <date> includes each tag on the route of the second hierarchy indicated by the start hierarchy <date> of the 0th hierarchy indicated by the root which is the highest hierarchy → the start tag <news> This is “/ news / date” in which the character strings in the tag are connected by “/”.

  The path condition is a path condition indicating a hierarchy in which a keyword exists, and is “/ news // name” in the example of FIG. “/ News // name” indicates a path from the 0th layer → the first layer “news” → an arbitrary layer “name”. “//” indicates that there may be any hierarchy on the route from the first hierarchy “news” to an arbitrary hierarchy “name”. Therefore, for example, the path “/ news / name”, the path “/ news / write / name”, the path “/ news / name / write / name”, and the like satisfy the conditions of the path in the query Q.

  The automaton A is information defining, for example, at least an initial state, a start state indicating a start tag symbol, and an end state indicating an end tag symbol. The start tag symbol is “<>” obtained by removing the character string in the tag from the start tag. The end tag symbol is “</>” obtained by removing the character string in the tag from the end tag.

  In the automaton A, various states used for matching the query Q may be further defined. The various states used for query Q verification include, for example, a path verification status indicating paths that satisfy the condition in query Q, a keyword verification intermediate state that is sequentially shifted from the path verification status by a keyword in query Q, and keyword verification completion. State. Further, since the storage area of the automaton A has an upper limit, it is assumed that the number of states that can be defined in the automaton A has an upper limit.

  In the following description, first, as an update example 1 of the automaton A, an example in which the collation processing apparatus 100 newly adds various states used for collation of the query Q to the automaton A until there is no free space in the automaton A. Show. Next, as an update example 2 of the automaton A, the collation processing apparatus 100 updates the automaton A by adding various states used for collation of the query Q to the automaton A when there is no free space in the automaton A. An example of the case is shown.

(Automata update example 1)
In the update example 1 of the automaton A, the matching processing device 100 reads from the head of the input stream S and detects a path that satisfies the condition of the query Q. Each time the verification processing device 100 detects a path that satisfies the query Q condition, the verification processing apparatus 100 counts the number of times of detection for each path that satisfies the query Q condition and generates a path verification state used for matching the keyword of the query Q.

  For example, the verification processing apparatus 100 detects a path “/ news / write / name” that satisfies the condition of the query Q, and generates a path verification state indicating the detected path. Here, a path ID unique to a path “/ news / write / name” that satisfies the condition of the query Q is assigned to the path verification state. In the example of FIG. 1, “4” is assigned.

  Further, the verification processing device 100 changes the transition destination from the start state. Specifically, the verification processing device 100 changes the transition from the start state to the path verification state, the transition from the path verification state to the start state or the end state, the transition from the path verification state to the keyword in the query Q, and the transition destination. Generate state.

  Further, the matching processing device 100 generates a transition destination state from the path matching state so that it can be matched with the keyword of the query Q when “Bob” is read when the scanning position of the input stream S is in the path matching state. The transition destination state is a first keyword matching intermediate state and a transition “B” from the path matching state to the first keyword matching intermediate state. The matching processing device 100 also includes a second keyword matching intermediate state that is a transition destination from the first keyword matching intermediate state, and a transition “o” from the first keyword matching intermediate state to the second keyword matching intermediate state. Is generated. Further, the matching processing device 100 generates a keyword matching completed state that is a transition destination from the second keyword matching intermediate state and a transition “b” from the second keyword matching intermediate state to the keyword matching completed state. .

  Further, the verification processing device 100 counts the number of times the path “/ news / write / name” is detected. Here, it is assumed that the collation processing apparatus 100 counts the number of detections “1” of the path “/ news / write / name”.

  Similarly, the verification processing apparatus 100 detects the path “/ news / edit / name”, generates a path verification state to which the path ID “7” of the path “/ news / edit / name” is assigned, and generates the automaton A. Stipulate. Further, the matching processing device 100 generates a keyword matching in-progress state and a keyword matching completed state and defines them in the automaton A. In addition, the verification processing device 100 counts the number of detections “1” of the path “/ news / edit / name”.

  Similarly, the verification processing apparatus 100 detects the path “/ news / prev / name” and generates a path verification state to which the path ID “9” of the path “/ news / prev / name” is assigned. Automaton A is specified. Further, the matching processing device 100 generates a keyword matching in-progress state and a keyword matching completed state and defines them in the automaton A. Further, the verification processing apparatus 100 counts the number of detections “1” of the path “/ news / prev / name”. Here, it is assumed that there is no free space in the automaton A.

  Thereafter, similarly, the matching processing apparatus 100 sequentially reads and processes the input stream S, counts the detection number “3” of the path “/ news / write / name”, and passes the path “/ news / edit / name”. Assume that the number of detections “3” is counted. Further, the number of detections of the path “/ news / prev / name” remains “1”. Thereby, the update example 1 of the automaton A ends.

(Automata update example 2)
In the update example 2 of the automaton A, the verification processing apparatus 100 detects a path “/ news / host / name” that satisfies the condition of the query Q. Here, since the automaton A has no free space, the path collation state to which the path ID “10” of the detected path “/ news / host / name” is assigned cannot be newly defined in the automaton A. .

  Therefore, the verification processing apparatus 100 deletes one of the path verification states defined in the automaton A, so that the path verification state to which the path ID “10” is assigned is newly assigned to the automaton A. Stipulate. Specifically, the verification processing apparatus 100 deletes the path verification state to which the path ID of the path with the low detection count is assigned based on the detection count counted for each path. Then, the verification processing device 100 generates a path verification state to which the path ID “10” is assigned, and newly defines it in the automaton A. Further, the matching processing device 100 generates a keyword matching in-progress state and a keyword matching completed state and defines them in the automaton A. Thereby, the update example 2 of the automaton A ends.

  Thus, in the update of the automaton A, the matching processing apparatus 100 leaves a path matching state in which the number of detections detected when the condition of the query Q is satisfied among the path matching states defined in the automaton A is relatively large. . Therefore, the verification processing apparatus 100 can leave a path verification state that is relatively likely to be scanned again later among the path verification states defined in the automaton A. In other words, the matching processing device 100 prevents a path matching state that is relatively likely to be scanned again later from being deleted, and subsequently generating the same path matching state again. be able to. As a result, the matching processing device 100 reduces the load of automaton update processing, suppresses processing delay time caused by generating a path matching state in the automaton A, and speeds up the query Q matching processing using the automaton A. can do.

<Example of collation between input stream S and query Q>
FIG. 2 is an explanatory diagram showing an example of collation between the input stream S and the query Q. The collation processing apparatus 100 outputs the keyword “Bob” when the keyword “Bob” is included in the hierarchy indicated by the path satisfying the path condition in the query Q in the input stream S. Here, the collation processing apparatus 100 may output information indicating the position of the character string “Bob” together with the character string “Bob”. The information indicating the position of the character string “Bob” may be, for example, a path or a line number where the character string “Bob” exists.

  FIG. 3 is an explanatory diagram illustrating an example of conversion of the input stream S. The verification processing apparatus 100 sequentially reads the input stream S from the first <news> to the last </ news>. The verification processing device 100 performs conversion on the tag. Thereby, since the tag is compressed, the automaton A can be reduced.

  In the example of FIG. 3, the start tag symbol “<>” is converted to “[”. Also, the end tag symbol “</>” is converted to “]”. In addition, each character string in the tag is converted into a unique number. In this example, they are converted into “1”, “2”,. For example, “news” is converted into “1”, “date” is converted into “2”, “write” is converted into “3”, and “name” is converted into “4”. In the following description, the converted input stream S may be referred to as “converted stream s”.

  FIG. 4 is an explanatory diagram showing the path of the input stream S. The path is information indicating a route from the top layer of the input stream S to the layer indicated by each tag. In the example of FIG. 4, for ease of understanding, the path will be described using a path schema for the input stream S for convenience. However, how the input stream S is configured is determined by reading the input stream S The collation processing apparatus 100 does not recognize until analysis.

  The path schema is a tree structure indicating the hierarchical structure of the input stream S. In the input stream S, “news” is the first hierarchy, “date” and “write” are the second hierarchy, and “name” is the third hierarchy. The path from the root of the 0th hierarchy to the "news" of the 1st hierarchy is the path p1, the path from the root to "date" is the path p2, the path from the root to "write" is the path p3, The path from the route to “name” is the path p4.

  The numbers assigned to the paths p1 to p4 correspond to the unique numbers converted in FIG. Specifically, the path p # (# is a number) is a path that reaches the hierarchy indicated by the tag of the tag character string converted to #. For example, the path p2 is a path that reaches the in-tag character string “date” converted to “2”. The path p4 is a path that reaches the in-tag character string “name” converted to “4”. # Is a path ID described later. While reading the input stream S, the verification processing apparatus 100 detects a path that ends with the tag currently being read.

  FIG. 5 is an explanatory diagram showing an example of the path ID management table. The path ID management table T is a table for managing path IDs. The path ID management table T includes a path ID item, a path item, a cumulative item, and a previous item, and the value of each item is stored as a record for each path.

  The path ID management table T is empty by default with no records. The path ID item stores a path ID. The path ID is identification information for uniquely specifying a path, and is # described above. A path is stored in the path item. For example, in the case of the path p4 with the path ID “4”, “/ news / write / name” is stored.

  The cumulative number field stores the cumulative number of times that the path matches the query Q condition. The cumulative number of times is, for example, the number of times that the tag reached by the path matches the query Q condition, and is cumulative regardless of the generation or deletion of the path matching state corresponding to the path.

  A flag is stored in the previous item. The flag is an identifier indicating, for example, whether a tag reached by the path has appeared as a start tag or an end tag. The flag is “(none)” when it does not appear, and is set to “start” if it appears as a start tag, and is set to “end” if it appears as a start tag after appearing as a start tag.

  For example, when the start tag <name> appears while the input stream S is being read, the verification processing apparatus 100 detects the path p4, and the path ID “4” and the path p4 are included in the new record of the path ID management table T. (/ News / write / name), cumulative count “1”, and flag “start” are registered. Thereafter, when the end tag </ name> appears, the collation processing device 100 changes the flag of the path p4 from “start” to “end”.

  In this way, a record is added to the path ID management table T every time a path is detected, and the flag is updated when the end tag is detected. Thereby, the cumulative number of passes can be detected. In addition, the start tag read immediately after the end tag can be detected by tracing from the layer one level higher than the path of the end tag. For example, the start tag <write> appears after the end tag </ date> of the path p2, but the path p3 is detected by going back to <new> after returning to <news> one level above. Can do.

  FIG. 6 is an explanatory diagram showing an example of the frequency management table. The frequency management table F is a table for managing the appearance frequency of the path ID. The frequency management table F has a path ID item, and each time a path appears, the value of the path ID item is stored as a record.

  The frequency management table F is empty by default with no records. The path ID item stores a path ID. As described above, the path ID is identification information that uniquely identifies a path, and is #.

  For example, when the start tag <name> appears while the input stream S is being read, the verification processing apparatus 100 detects the path p4 and registers the path ID “4” in the new record of the frequency management table F.

  The frequency management table F is a table in which the upper limit of the number of records is determined. When a new record is stored when the number of records reaches the upper limit, the oldest record is deleted and a new record is stored. To do. In this way, a record is added to the frequency management table F every time a path is detected.

  FIG. 7 is an explanatory diagram showing a construction example of the initial automaton A0. As shown in FIG. 1, the verification processing apparatus 100 stores an initial automaton A0. Since the initial automaton A0 can be applied to any input stream S, it may be constructed at a certain timing and stored in the verification processing apparatus 100. When the initial automaton A0 is not yet constructed, the verification processing apparatus 100 generates an initial state N0 and a start state N1 indicating the start tag symbol “[” converted from the start tag symbol “<>” in (A). . In addition, the verification processing device 100 generates an end state N2 indicating the end tag symbol “]” converted from the end tag symbol “</>”.

  Then, the verification processing device 100 generates a transition t00 that is a loop of the initial state N0 itself, a transition t10 from the start state N1 to the initial state N0, and a transition t20 from the end state N2 to the initial state N0. “Σ” indicates all symbols. Note that, in a transition code txy in the following drawings, x indicates a state ID of a transition source state, and y indicates a state ID of a transition destination state.

  In (B), the verification processing device 100 deletes “[” and “]” from the transition t00 that is the loop of the initial state N0 itself, and the transition t01 from the initial state N0 to the start state N1 and the initial state N0. A transition t02 to the end state N2 is generated. Thereby, the initial automaton A0 is constructed. The constructed initial automaton A0 is stored in a storage area in the verification processing apparatus 100, and is read each time reception of the input stream S is started.

  FIG. 8 is an explanatory diagram illustrating an example of a node structure. The node structure N is a data structure that stores the characteristics of the state of the automaton A. Specifically, the node structure N stores a state ID, a state type, a node counter, and a list L for each state. The state ID is identification information that uniquely identifies the state. Each state is assigned unique identification information as a state ID. The type of state is attribute information that identifies what type the state is. For example, there are “initial state”, “start state”, and “end state” described above. In addition, there are a “path verification state”, a “keyword verification in progress”, and a “keyword verification completion status”. The “path verification status”, “keyword verification in progress”, and “keyword verification completion status” will be described later.

  The node counter is the number of transitions from the start state to the node. The list L is a data structure that holds a transition that specifies a state transition destination state. Specifically, an area is prepared for each symbol in the list L, and the state ID of the transition destination state is stored in the area. FIG. 9 shows the node structure N in each state defined in the initial automaton A0.

  FIG. 9 is an explanatory diagram showing an example of the node structure N in each state in the initial automaton A0. 9A shows the node structure N in the initial state N0, FIG. 9B shows the node structure N in the start state N1, and FIG. 9C shows the node structure N in the end state N2.

  In (A), the state ID of the initial state N0 is “0”. Further, since the state is the initial state N0, the state type is “initial”. In addition, when “[” appears in the initial state N0, the state transitions to the start state N1, and thus the state ID “1” of the start state N1 is stored in the area of the symbol “[” in the list L. Similarly, when “]” appears in the initial state N0, the state transitions to the end state N2, and thus the state ID “2” of the end state N2 is stored in the area of the symbol “]” of the list L. . Further, each of “Σ \ {[,]}” excluding “[” and “]” among all symbols Σ loops to the initial state N0 itself, and therefore “Σ \ {[,]}” In each symbol area, the state ID “0” of the initial state N0 is stored.

  In (B), the state ID of the start state N1 is “1”. Further, since the state is the start state N1, the state type is “start”. In addition, since any symbol of all symbols Σ appears in the start state N1, the state transitions to the initial state N0. Therefore, the state ID “0” of the initial state N0 is set in each symbol area of the list L. Stored.

  In (C), the state ID of the end state N2 is “2”. Further, since the state is the end state N2, the state type is “end”. In addition, since any symbol of all symbols Σ appears in the end state N2, the state transitions to the initial state N0. Therefore, the state ID “0” of the initial state N0 is set in each symbol area of the list L. Stored. The path matching state, the keyword matching in progress state, and the keyword matching completion state that are not included in the initial automaton A0 are also the node structures N similar to (A) to (C).

<Operation Example of Collation Processing Device 100>
Next, an operation example of the verification processing apparatus 100 will be specifically described. In the following figures, the flag indicates the current position of the automaton A, and the thick arrow indicates scanning.

  The verification processing apparatus 100 can perform an operation of updating the automaton A using, for example, the cumulative number of times of the path ID management table T. In the following description, the operation of updating the automaton A using the cumulative number of the path ID management table T performed by the matching processing apparatus 100 may be referred to as “first operation example”.

  Further, for example, the verification processing apparatus 100 can perform an operation of correcting the automaton A using the corrected cumulative number of times by correcting the cumulative number of the path ID management table T by the frequency management table F. In the following description, the operation of updating the automaton A using the corrected cumulative number may be referred to as “second operation example”.

  In addition, the verification processing apparatus 100 can perform an operation of updating the automaton A by using, for example, the cumulative number of times in the path ID management table T and the flag. In the following description, the operation of updating the automaton A using the cumulative number of times in the path ID management table T and the flag may be referred to as “third operation example”.

(First operation example of collation processing apparatus 100)
First, a first operation example of the verification processing apparatus 100 will be described with reference to FIGS. 10 to 30 are explanatory diagrams illustrating a first operation example of the collation processing device 100. In the first operation example, the previous item of the path ID management table T may not be present, and the frequency management table F may not be present. Therefore, in FIG. 10 to FIG. 30, the notation of the previous item of the path ID management table T and the frequency management table F is omitted.

  FIG. 10 shows a state before the scanning of the initial automaton A0. In FIG. 10, a query Q and an initial automaton A0 are prepared. Also, a first buffer b1 in which each input data of the input stream S is stored, a second buffer b2 in which converted input data converted from the input data is stored, and a third buffer b3 in which the current path is registered , Is prepared. Since FIG. 10 is before scanning, the first buffer b1, the second buffer b2, and the third buffer b3 are empty. Further, there is no record in the path ID management table T.

  Next, the description proceeds to FIG. FIG. 11 shows processing when the start tag <news>, which is the top data of the record 1 of the input stream S, is received from the state of FIG.

  In FIG. 11, when the start tag <news>, which is the top data of the input stream S, is written to the first buffer b1, the verification processing apparatus 100 reads <news>, converts it to "[1", and converts it to the second buffer. Write to b2. Also, since the start tag <news> has been received, the verification processing apparatus 100 detects “/ news” as the current path p and writes it to the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “1”, the path “/ news” in the third buffer b3, and the cumulative number “(none)” in the path ID management table T.

  Since the path p1 of the third buffer b3 does not match the condition of the query Q, the collation processing device 100 scans from the initial state N0 that is the scanning position to the start state N1 by “[” of the second buffer b2, and the second Scanning from the start state N1 to the initial state N0 is performed by "1" in the buffer b2.

  Next, the description proceeds to FIG. FIG. 12 shows processing when the start tag <date> of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 12, when the start tag <date> of the input stream S is written to the first buffer b1, the verification processing device 100 reads <date>, converts it to “[2”, and writes it to the second buffer b2. Also, since the start tag <date> has been received, the verification processing apparatus 100 writes “/ date” at the end of “/ news” in the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “2”, the path “/ news / date” in the third buffer b3, and the cumulative number “(none)” in the path ID management table T.

  Further, the path p2 of the third buffer b3 does not match the condition of the query Q. Therefore, the collation processing device 100 scans from the initial state N0, which is the scanning position, to the start state N1 by “[” of the second buffer b2, and from the start state N1 to the initial state by “2” of the second buffer b2. Scan to N0.

  Next, the description proceeds to FIG. FIG. 13 shows processing when the character string “2011-12-01” of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 13, when the character string “2011-12-01” of the input stream S is written to the first buffer b1, the collation processing device 100 reads the character string “2011-12-01” and converts the character string “2011-12-01” without conversion. 2 Write to buffer b2. When a character string is received, registration in the path ID management table T is not executed.

  Then, the collation processing device 100 scans from the initial state N0 that is the scanning position to the initial state N0 by the first character “2” of the character string “2011-12-01” in the second buffer b2. The collation processing apparatus 100 similarly scans from the initial state N0 to the initial state N0 by the characters after the head of the character string “2011-12-01” in the second buffer.

  Next, the description proceeds to FIG. FIG. 14 shows processing when the end tag </ date> of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 14, when the end tag </ date> of the input stream S is written to the first buffer b1, the verification processing apparatus 100 reads </ date>, converts it to "] 2", and stores it in the second buffer b2. Write. Further, the verification processing device 100 deletes the character string “date” of “/” and the end tag </ date> from the path p2: “/ news / date” of the third buffer b3, and passes the path p1: “ / News ".

  Further, the path p1 of the third buffer b3 does not match the query Q condition. For this reason, the collation processing device 100 scans from the initial state N0, which is the scanning position, to the end state N2 by “]” of the second buffer b2, and from the end state N2 to the initial state by “2” of the second buffer b2. Scan to N0.

  Next, the description proceeds to FIG. FIG. 15 shows processing when the start tag <write> of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 15, when the start tag <write> of the input stream S is written to the first buffer b1, the verification processing apparatus 100 reads <write>, converts it to “[3”, and writes it to the second buffer b2. Also, since the start tag <write> has been received, the verification processing apparatus 100 writes “/” and the in-tag character string “write” at the end of “/ news” in the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “3”, the path “/ news / write”, and the cumulative number “(none)” in the third buffer b3 in the path ID management table T.

  Further, the path p3 of the third buffer b3 does not match the query Q condition. Therefore, the collation processing device 100 scans from the initial state N0, which is the scanning position, to the start state N1 by “[” of the second buffer b2, and from the start state N1 to the initial state by “3” of the second buffer b2. Scan to N0.

  Next, the description proceeds to FIG. FIG. 16 shows processing when the start tag <name> of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 16, when the start tag <name> of the input stream S is written to the first buffer b1, the verification processing device 100 reads <name>, converts it to “[4”, and writes it to the second buffer b2. Further, since the start tag <name> has been received, the verification processing apparatus 100 writes “/” and the in-tag character string “name” at the end of “/ news / write” in the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “4”, the path “/ news / write / name” in the third buffer b3, and the cumulative number “(none)” in the path ID management table T. Here, the path p4 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 updates the cumulative number of records from “(none)” to “1”.

  The path p4 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 executes the first update of the automaton A. Specifically, the verification processing device 100 first generates a new state. The new state is a state indicating the path ID “4”. Since this state is a state that specifies the path p4 that satisfies the condition of the query Q, in the following description, this state may be referred to as a “path verification state”.

  Further, since “[4” is written in the second buffer b2, the path verification state N3 becomes the transition destination state from the start state N1. At this time, specifically, the state ID of the path matching state N3 is stored in the area of the symbol “4” in the list L of the start state N1. In the following description, for the sake of simplicity, description of updating the list L in each state is omitted. Accordingly, when transition is made with the symbol “Σ \ {4}” excluding the path ID “4” in the symbol Σ, the transition destination of the start state N1 is the initial state N0. On the other hand, when the transition is made with the path ID “4”, the transition destination of the start state N1 is the path verification state N3.

  In addition, when the path matching state N3 is generated, the matching processing device 100 generates a transition destination state that is sequentially shifted from the path matching state N3 by characters constituting the keyword of the query Q. In the following description, a transition destination state that is transitioned by a character other than the last character among transition destination states that are transitioned by characters constituting the keyword may be referred to as a “keyword matching intermediate state”. In the following description, the transition destination state that is transitioned by the end character may be referred to as a “keyword matching completion state”.

  In the example of FIG. 16, the transition destination states that are transitioned by the first character “B” and the second character “o” are the keyword matching intermediate states N4 and N5, and the transition destination state that is transitioned by the last character “b” is The keyword collation completion state N6 is entered.

  Further, the matching processing device 100 generates a transition (not shown) from the path matching state N3 to the start state N1 and a transition (not shown) to the end state N2. The matching processing device 100 also generates a transition (not shown) in which the path matching state N3 loops to itself. This transition is a symbol “Σ \ {[,], B}” obtained by removing the start tag symbol “[”, the end tag symbol “]” and the first character “B” of the keyword from all symbols Σ. Thereby, the first update of the automaton A is completed.

  The verification processing device 100 starts scanning with the updated automaton A. The collation processing device 100 scans from the initial state N0 which is the scanning position to the start state N1 by “[” of “[4” of the second buffer b2, and from the start state N1 by “4” of the second buffer b2. Scan to the path verification state N3. The scanning position is in a path verification state N3. When the verification processing device 100 scans the path verification state N3, the node counter in the path verification state N3 is updated from “0” to “1”. 16 to 42, the numbers shown at the upper right of the path verification state indicate the values of the node counters in the path verification state.

  Next, the description proceeds to FIG. FIG. 17 shows processing when the character string “Alice” of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 17, when the character string “Alice” of the input stream S is written into the first buffer b1, the verification processing apparatus 100 reads the character string “Alice” and writes it into the second buffer b2 without conversion. When a character string is received, registration in the path ID management table T is not executed.

  In addition, since the first character “A” in the character string “Alice” in the second buffer b2 is different from the first character “B” of the keyword, the collation processing device 100 uses the character “A” to determine the path collation state that is the scanning position. Scan from N3 to path verification state N3. Further, the matching processing device 100 similarly scans from the path matching state N3 to the path matching state N3 by the characters after the head of the character string “Alice” in the second buffer.

  Next, the description proceeds to FIG. FIG. 18 shows processing when the end tag </ name> of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 18, when the end tag </ name> of the input stream S is written to the first buffer b1, the verification processing device 100 reads </ name>, converts it to "] 4", and stores it in the second buffer b2. Write. Further, the verification processing apparatus 100 deletes the character string “name” in the tag “/” and the end tag </ name> from the path p4: “/ news / write / name” of the third buffer b3, and passes the path p3. : Return to “/ news / write”.

  Further, the path p3 of the third buffer b3 does not match the query Q condition. For this reason, the collation processing apparatus 100 scans from the path collation state N3 that is the scanning position to the end state N2 by “]” of the second buffer b2, and from the end state N2 by “4” of the second buffer b2. Scan to state N0.

  Next, the description shifts to the description of FIG. FIG. 19 shows processing when the end tag </ write> of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 19, when the end tag </ write> of the input stream S is written to the first buffer b1, the verification processing device 100 reads </ write>, converts it to "] 3", and stores it in the second buffer b2. Write. Further, the verification processing apparatus 100 deletes “/” and the character string “write” in the tag of the end tag </ write> from the path p3: “/ news / write” of the third buffer b3, and passes the path p1: “ / News ".

  Further, the path p1 of the third buffer b3 does not match the query Q condition. For this reason, the collation processing device 100 scans from the initial state N0, which is the scanning position, to the end state N2 by “]” of the second buffer b2, and from the end state N2 to the initial state by “3” of the second buffer b2. Scan to N0.

  Next, the description shifts to the description of FIG. FIG. 20 shows a process when the start tag <edit> of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 20, when the start tag <edit> of the input stream S is written to the first buffer b1, the verification processing apparatus 100 reads <edit>, converts it to “[5”, and writes it to the second buffer b2. Also, since the start tag <edit> has been received, the verification processing apparatus 100 writes “/” and the in-tag character string “edit” at the end of “/ news” in the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “5”, the path “/ news / edit” in the third buffer b3, and the cumulative number “(none)” in the path ID management table T.

  Further, the path p3 of the third buffer b3 does not match the query Q condition. For this reason, the collation processing device 100 scans from the initial state N0, which is the scanning position, to the start state N1 by “[” of the second buffer b2, and from the start state N1 to the initial state by “5” of the second buffer b2. Scan to N0.

  Next, the description proceeds to FIG. FIG. 21 shows processing when the start tag <name> of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 21, when the start tag <name> of the input stream S is written to the first buffer b1, the verification processing device 100 reads <name>, converts it to “[6”, and writes it to the second buffer b2. Since the start tag <name> has been received, the verification processing apparatus 100 writes “/” and the in-tag character string “name” at the end of “/ news / edit” in the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “6”, the path “/ news / edit / name” in the third buffer b3, and the cumulative number “(none)” in the path ID management table T. Here, the path p6 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 updates the cumulative number of records from “(none)” to “1”.

  The path p6 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 executes the second update of the automaton A. Specifically, the matching processing device 100 generates a path matching state N7 that identifies the path p6 that satisfies the condition of the query Q. When the path matching state N7 is generated, the matching processing device 100 sets the keyword matching intermediate states N8, N9 and the keyword matching as the transition destination states that are sequentially shifted from the path matching state N7 by the characters of the keyword of the query Q. A completion state N10 is generated.

  Further, the matching processing device 100 generates a transition (not shown) from the path matching state N7 to the start state N1 and a transition (not shown) to the end state N2. The matching processing device 100 also generates a transition (not shown) in which the path matching state N7 loops to itself. This transition is a symbol “Σ \ {[,], B}” obtained by removing the start tag symbol “[”, the end tag symbol “]” and the first character “B” of the keyword from all symbols Σ. This completes the second update of the automaton A.

  The verification processing device 100 starts scanning with the updated automaton A. The collation processing device 100 scans from the initial state N0 which is the scanning position to the start state N1 by “[” of “[6” of the second buffer b2, and from the start state N1 by “6” of the second buffer b2. Scan to the path verification state N7. The scanning position is in a path verification state N7. When the verification processing device 100 scans the path verification state N7, the node counter of the path verification state N7 is updated from “0” to “1”.

  Next, the description shifts to the description of FIG. FIG. 22 shows processing when the character string “Bob” of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 22, when the character string “Bob” of the input stream S is written to the first buffer b1, the verification processing apparatus 100 reads the character string “Bob” and writes it to the second buffer b2 without conversion. When a character string is received, registration in the path ID management table T is not executed.

  In addition, since the first character “B” in the character string “Bob” in the second buffer b2 matches the first character “B” of the keyword, the verification processing device 100 uses the character “B” to verify the path verification that is the scanning position. Scan from the state N7 to the keyword collation intermediate state N8. Next, the matching processing device 100 scans from the keyword matching intermediate state N8 that is the scanning position to the next keyword matching intermediate state N9 by the second character “o” in the character string “Bob”.

  Then, the matching processing device 100 scans from the keyword matching in-progress state N9 to the keyword matching completed state N10 by the end character “b” in the character string “Bob”. Here, since the keyword matching completion state N10 is scanned, the matching processing device 100 outputs the keyword “Bob” of the query Q.

  Next, the description proceeds to FIG. FIG. 23 shows processing when the end tag </ name> of the record 1 of the input stream S is received from the state of FIG.

  In FIG. 23, when the end tag </ name> of the input stream S is written to the first buffer b1, the verification processing device 100 reads </ name>, converts it to "] 6", and stores it in the second buffer b2. Write. Further, the verification processing apparatus 100 deletes “/” and the in-tag character string “name” of the end tag </ name> from the path p6: “/ news / edit / name” of the third buffer b3, and passes the path p5 : Return to “/ news / edit”.

  Here, the path p5 of the third buffer b3 does not match the query Q condition. For this reason, the collation processing device 100 scans from the keyword collation completion state N10 that is the scanning position to the end state N2 by “]” of the second buffer b2, and from the end state N2 by “6” of the second buffer b2. Scan to the initial state N0.

  Next, the description proceeds to FIG. FIG. 24 shows a processing result when each remaining data of the record 1 of the input stream S is received from the state of FIG. 23 and processed in the same manner as FIGS. .

  In FIG. 24, when the start tag <prev> is received, the collation processing device 100 writes the data obtained by converting the start tag <prev> into the second buffer b2, and the third buffer b3 is updated by the current path. The Further, a record relating to the path ID “7” is registered in the path ID management table T, and the automaton A is scanned.

  Next, when the start tag <write> is received, the collation processing device 100 writes the data obtained by converting the start tag <write> into the second buffer b2, and updates the third buffer b3. Further, a record related to the path ID “8” is registered in the path ID management table T, and the automaton A is scanned.

  When the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. Further, a record related to the path ID “9” is registered in the path ID management table T, and the automaton A is scanned. Further, a path collation state N11, keyword collation intermediate states N12 and N13, and a keyword collation completion state N14 are generated in the automaton A. Further, the node counter in the path verification state N11 is updated from “0” to “1”.

  Next, the character string “Carol” is received, the end tag </ name> is received, the end tag </ write> is received, the end tag </ prev> is received, and the end tag </ news> is received. Is done. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The The scanning position is in the initial state N0.

  Next, the description proceeds to FIG. FIG. 25 shows a processing result when each data of the record 2 of the input stream S is received from the state of FIG. 24 and processed in the same manner as in FIGS.

  In FIG. 25, the start tag <news> is received, the start tag <date> is received, the character string “2011-12-02” is received, the end tag </ date> is received, and the start tag <write> is received. Is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . Further, the cumulative number related to the path ID “4” in the path ID management table T is updated from “1” to “2”, and the automaton A is scanned. Further, the node counter of the path verification state N3 that specifies the path ID “4” is updated from “1” to “2”.

  Next, the character string “Carol” is received, the end tag </ name> is received, the end tag </ write> is received, and the start tag <edit> is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and updates the third buffer b3. In addition, the cumulative number related to the path ID “6” in the path ID management table T is updated from “1” to “2”, and the automaton A is scanned. In addition, the node counter of the path verification state N7 that specifies the path ID “6” is updated from “1” to “2”.

  Next, the character string “Dick” is received, the end tag </ name> is received, the end tag </ edit> is received, and the end tag </ news> is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The The scanning position is in the initial state N0.

  Next, the description proceeds to FIG. FIG. 26 shows a processing result when each piece of data from the state of FIG. 25 to the middle of the record 3 of the input stream S is received and processed in the same manner as in FIGS. Yes.

  In FIG. 26, the start tag <news> is received, the start tag <date> is received, the character string “2011-12-03” is received, the end tag </ date> is received, and the start tag <write> is received. Is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and updates the third buffer b3. In addition, the cumulative number related to the path ID “4” in the path ID management table T is updated from “2” to “3”, and the automaton A is scanned. Further, the node counter in the path verification state N3 that specifies the path ID “4” is updated from “2” to “3”.

  Next, the character string “Alice” is received, the end tag </ name> is received, the end tag </ write> is received, and the start tag <edit> is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and updates the third buffer b3. Further, the cumulative number related to the path ID “6” in the path ID management table T is updated from “2” to “3”, and the automaton A is scanned. In addition, the node counter in the path verification state N7 that specifies the path ID “6” is updated from “2” to “3”.

  Next, the character string “Dick” is received, the end tag </ name> is received, the end tag </ edit> is received, the start tag <prev> is received, and the start tag <write> is received. . Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . In addition, the cumulative number related to the path ID “9” in the path ID management table T is updated from “1” to “2”, and the automaton A is scanned. Further, the node counter of the path verification state N11 that specifies the path ID “9” is updated from “1” to “2”.

  Next, the character string “Carol” is received, the end tag </ name> is received, and the end tag </ write> is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <edit> is received, the collation processing device 100 writes the data obtained by converting the start tag <edit> into the second buffer b2, and updates the third buffer b3. Further, a record related to the path ID “10” is registered in the path ID management table T, and the automaton A is scanned.

  Next, the description proceeds to FIG. FIG. 27 shows processing when the start tag <name> of the record 3 of the input stream S is received from the state of FIG.

  In FIG. 27, when the start tag <name> of the input stream S is written to the first buffer b1, the verification processing apparatus 100 reads <name>, converts it to “[11”, and writes it to the second buffer b2. Also, since the start tag <name> has been received, the verification processing apparatus 100 writes “/” and the in-tag character string “name” at the end of “/ news / prev / edit” in the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “11”, the path “/ news / prev / edit / name” in the third buffer b3, and the cumulative number “(none)” in the path ID management table T. To do. Here, the path p11 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 updates the cumulative number of records from “(none)” to “1”.

  The path p11 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 executes the third update of the automaton A. Specifically, the matching processing device 100 generates a path matching state N15 that identifies the path p11 that satisfies the condition of the query Q. At this time, since the maximum specified number of path verification states are already specified in the automaton A, the verification processing apparatus 100 selects one of the path verification states N3, N7, and N11 specified in the automaton A. The path verification state is deleted and a path verification state N15 is generated.

  For example, the verification processing apparatus 100 specifies the path ID “9” that minimizes the cumulative number of times in the path ID management table T. Next, the verification processing apparatus 100 deletes the path verification state N11 that specifies the specified path ID “9”. Then, with the deletion of the path verification state N11, the verification processing device 100 deletes the keyword verification intermediate states N12 and N13 and the keyword verification completion state N14 that are sequentially shifted from the path verification state N11. Next, the matching processing device 100 generates a path matching state N15. When the path matching state N15 is generated, the matching processing device 100 sets the keyword matching intermediate states N16, N17 and the keyword as transition destination states that are sequentially shifted from the path matching state N15 by the characters constituting the keyword of the query Q. A verification completion state N18 is generated.

  Further, the matching processing device 100 generates a transition (not shown) from the path matching state N15 to the start state N1 and a transition (not shown) to the end state N2. The matching processing device 100 also generates a transition (not shown) in which the path matching state N15 loops to itself. This transition is a symbol “Σ \ {[,], B}” obtained by removing the start tag symbol “[”, the end tag symbol “]” and the first character “B” of the keyword from all symbols Σ. Thus, the third update of the automaton A is completed.

  The verification processing device 100 starts scanning with the updated automaton A. The collation processing device 100 scans from the initial state N0 which is the scanning position to the start state N1 by “[” of “[11” of the second buffer b2, and from the start state N1 by “11” of the second buffer b2. Scan to the path verification state N15. The scanning position is in a path verification state N15. When the verification processing device 100 scans the path verification state N15, the node counter of the path verification state N15 is updated from “0” to “1”.

  Here, the verification processing device 100 deletes the path verification status N11 and generates the path verification status N15, but this is not a limitation. For example, the verification processing apparatus 100 may delete the path verification state N11 after generating the path verification state N15. Further, for example, the verification processing apparatus 100 may delete the path verification state N11 and generate the path verification state N15 by overwriting the path verification state N15 on the path verification state N11. In this case, the matching processing device 100 may divert the keyword matching intermediate states N12 and N13 and the keyword matching completion state N14 as the keyword matching intermediate states N16 and N17 and the keyword matching completion state N18.

  Next, the description proceeds to FIG. FIG. 28 shows a processing result when each remaining data of the record 3 of the input stream S is received from the state of FIG. 27 and processed by the matching processing device 100 in the same manner as in FIGS. .

  In FIG. 28, the character string “Bob” is received, the end tag </ name> is received, the end tag </ edit> is received, the end tag </ prev> is received, and the end tag </ news> is set. Received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The In FIG. 28, the path ID management table T is not updated. Also, automaton A is not updated. The scanning position is in the initial state N0.

  Next, the description proceeds to FIG. FIG. 29 shows a processing result when each data of the record 4 of the input stream S is received from the state of FIG. 28 and processed in the same way as in FIGS.

  In FIG. 29, the start tag <news> is received, the start tag <date> is received, the character string “2011-12-04” is received, the end tag </ date> is received, and the start tag <write> is received. Is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . In addition, the cumulative number related to the path ID “4” in the path ID management table T is updated from “3” to “4”, and the automaton A is scanned. In addition, the node counter in the path verification state N3 that specifies the path ID “4” is updated from “3” to “4”.

  Next, the character string “Carol” is received, the end tag </ name> is received, the end tag </ write> is received, the start tag <prev> is received, and the start tag <write> is received. . Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . In addition, the cumulative number related to the path ID “9” in the path ID management table T is updated from “2” to “3”, and the automaton A is scanned. Also, based on the cumulative number of times in the path ID management table T, the path verification state N15 that specifies the path with the path ID “11” is deleted, and the path verification state N11 that specifies the path with the path ID “9” is recreated. The Further, the node counter of the path verification state N11 that specifies the path ID “9” is updated from “0” to “1”.

  Next, the character string “Alice” is received, the end tag </ name> is received, the end tag </ write> is received, and the start tag <write> is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . In addition, the cumulative number related to the path ID “9” in the path ID management table T is updated from “3” to “4”, and the automaton A is scanned. Further, the node counter of the path verification state N11 that specifies the path ID “9” is updated from “1” to “2”.

  Next, the character string “Bob” is received, the end tag </ name> is received, the end tag </ write> is received, the end tag </ prev> is received, and the end tag </ news> is received. Is done. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The The scanning position is in the initial state N0.

  Next, the description proceeds to FIG. FIG. 30 shows a processing result when each data of the record 5 of the input stream S is received from the state of FIG. 29 and processed in the same manner as in FIGS.

  In FIG. 30, the start tag <news> is received, the start tag <date> is received, the character string “2011-12-05” is received, the end tag </ date> is received, and the start tag <prev> Is received and the start tag <edit> is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. Further, the cumulative number of times related to the path ID “11” in the path ID management table T is updated from “1” to “2”. Further, based on the cumulative number of times in the path ID management table T, the path verification state N7 that specifies the path with the path ID “6” is deleted, and the path verification state N15 that specifies the path with the path ID “11” is recreated. The Further, the node counter in the path verification state N15 that specifies the path ID “11” is updated from “0” to “1”.

  Next, the character string “Dick” is received, the end tag </ name> is received, the end tag </ edit> is received, the end tag </ prev> is received, and the end tag </ news> is received. Is done. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The The scanning position is in the initial state N0.

  Thus, in the update of the automaton A, the matching processing apparatus 100 leaves a path matching state in which the number of detections detected when the condition of the query Q is satisfied among the path matching states defined in the automaton A is relatively large. . Therefore, the verification processing apparatus 100 can leave a path verification state that is relatively likely to be scanned again later among the path verification states defined in the automaton A. In other words, the matching processing device 100 prevents a path matching state that is relatively likely to be scanned again later from being deleted, and subsequently generating the same path matching state again. be able to. As a result, the matching processing device 100 reduces the load of automaton update processing, suppresses processing delay time caused by generating a path matching state in the automaton A, and speeds up the query Q matching processing using the automaton A. can do.

(Second operation example of collation processing apparatus 100)
Next, a second operation example of the verification processing device 100 will be described with reference to FIGS. FIGS. 31 to 36 are explanatory diagrams illustrating a second operation example of the verification processing device 100. In the second operation example, the previous item of the path ID management table T may not be present. Therefore, in FIG. 31 to FIG. 36, the previous item of the path ID management table T is not shown.

  FIG. 31 shows a state before the scanning of the initial automaton A in the second operation example. In FIG. 31, in addition to the query Q, the initial automaton A, the first buffer b1, the second buffer b2, and the third buffer b3 shown in FIG. A frequency management table F to be stored is prepared.

  Since FIG. 31 is before scanning, the first buffer b1, the second buffer b2, and the third buffer b3 are empty. Further, there is no record in the path ID management table T and the frequency management table F. Thereafter, the collation processing apparatus 100 processes each data of the record 1 of the input stream S in the same manner as in FIGS.

  Next, the description shifts to the description of FIG. FIG. 32 shows processing when the start tag <name> of the record 1 of the input stream S is received as in FIG.

  In FIG. 32, when the start tag <name> of the input stream S is written to the first buffer b1, the verification processing device 100 reads <name>, converts it to “[4”, and writes it to the second buffer b2. Further, since the start tag <name> has been received, the verification processing apparatus 100 writes “/” and the in-tag character string “name” at the end of “/ news / write” in the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “4”, the path “/ news / write / name” in the third buffer b3, and the cumulative number “(none)” in the path ID management table T. Here, the path p4 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 updates the cumulative number of records from “(none)” to “1”. The path p4 of the third buffer b3 matches the query Q condition. Therefore, the verification processing apparatus 100 registers the path ID “4” in the frequency management table F.

  The path p4 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 updates the automaton A. Specifically, the matching processing device 100 first generates a path matching state N3 indicating the path ID “4”. When the path matching state N3 is generated, the matching processing device 100 sets the keyword matching in-progress states N4 and N5 as transition destination states that are sequentially shifted from the path matching state N3 by the characters constituting the keyword of the query Q. A keyword matching completion state N6 is generated.

  Further, the matching processing device 100 generates a transition (not shown) from the path matching state N3 to the start state N1 and a transition (not shown) to the end state N2. The matching processing device 100 also generates a transition (not shown) in which the path matching state N3 loops to itself. This transition is a symbol “Σ \ {[,], B}” obtained by removing the start tag symbol “[”, the end tag symbol “]” and the first character “B” of the keyword from all symbols Σ. Thereby, the first update of the automaton A is completed.

  The verification processing device 100 starts scanning with the updated automaton A. The collation processing device 100 scans from the initial state N0 which is the scanning position to the start state N1 by “[” of “[4” of the second buffer b2, and from the start state N1 by “4” of the second buffer b2. Scan to the path verification state N3. The scanning position is in a path verification state N3.

  When the verification processing device 100 scans the path verification state N3, the node counter in the path verification state N3 is updated from “0” to “1”. Thereafter, the collation processing apparatus 100 processes each data of the record 1 of the input stream S in the same manner as in FIGS.

  Next, the description proceeds to FIG. FIG. 33 shows processing when the start tag <name> of the record 1 of the input stream S is received as in FIG.

  In FIG. 33, when the start tag <name> of the input stream S is written to the first buffer b1, the verification processing device 100 reads <name>, converts it to “[6”, and writes it to the second buffer b2. Since the start tag <name> has been received, the verification processing apparatus 100 writes “/” and the in-tag character string “name” at the end of “/ news / edit” in the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “6”, the path “/ news / edit / name” in the third buffer b3, and the cumulative number “(none)” in the path ID management table T. Here, the path p6 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 updates the cumulative number of records from “(none)” to “1”. The path p6 of the third buffer b3 matches the query Q condition. For this reason, the verification processing apparatus 100 registers the path ID “6” in the frequency management table F.

  The path p6 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 updates the automaton A. Specifically, the matching processing device 100 generates a path matching state N7 that identifies the path p6 that satisfies the condition of the query Q. When the path matching state N7 is generated, the matching processing device 100 sets the keyword matching intermediate states N8, N9 and the keyword as transition destination states that are sequentially shifted from the path matching state N7 by the characters constituting the keyword of the query Q. A verification completion state N10 is generated.

  Further, the matching processing device 100 generates a transition (not shown) from the path matching state N7 to the start state N1 and a transition (not shown) to the end state N2. The matching processing device 100 also generates a transition (not shown) in which the path matching state N7 loops to itself. This transition is a symbol “Σ \ {[,], B}” obtained by removing the start tag symbol “[”, the end tag symbol “]” and the first character “B” of the keyword from all symbols Σ. This completes the second update of the automaton A.

  The verification processing device 100 starts scanning with the updated automaton A. The collation processing device 100 scans from the initial state N0 which is the scanning position to the start state N1 by “[” of “[6” of the second buffer b2, and from the start state N1 by “6” of the second buffer b2. Scan to the path verification state N7. The scanning position is in a path verification state N7. When the verification processing device 100 scans the path verification state N7, the node counter of the path verification state N7 is updated from “0” to “1”. Thereafter, the collation processing apparatus 100 processes each data of the record 1 of the input stream S in the same manner as in FIG. 22 and FIG.

  Next, the description shifts to the description of FIG. FIG. 34 shows the processing result when the remaining data of the record 1 of the input stream S is received and processed by the matching processing device 100 as in FIG.

  In FIG. 34, when the start tag <prev> is received, the collation processing device 100 writes the data obtained by converting the start tag <prev> into the second buffer b2, and the third buffer b3 is updated by the current path. The Further, a record relating to the path ID “7” is registered in the path ID management table T, and the automaton A is scanned.

  Next, when the start tag <write> is received, the collation processing device 100 writes the data obtained by converting the start tag <write> into the second buffer b2, and the third buffer b3 is updated by the current path. . Further, a record related to the path ID “8” is registered in the path ID management table T, and the automaton A is scanned.

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . Further, a record related to the path ID “9” is registered in the path ID management table T, and the automaton A is scanned. Further, the path ID “9” is registered in the frequency management table F. Further, a path collation state N11, keyword collation intermediate states N12 and N13, and a keyword collation completion state N14 are generated in the automaton A. The node counter in the path verification state N11 is updated from “0” to “1”.

  Next, the character string “Carol” is received, the end tag </ name> is received, the end tag </ write> is received, the end tag </ prev> is received, and the end tag </ news> is received. Is done. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The The scanning position is in the initial state N0.

  Next, the description proceeds to FIG. FIG. 35 shows a processing result when each data of the record 2 of the input stream S is received from the state of FIG. 34 and processed by the collation processing device 100 as in FIG.

  35, the start tag <news> is received, the start tag <date> is received, the character string “2011-12-02” is received, the end tag </ date> is received, and the start tag <write> is received. Is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . Further, the cumulative number related to the path ID “4” in the path ID management table T is updated from “1” to “2”, and the automaton A is scanned. Further, the path ID “4” is registered in the frequency management table F. Further, the node counter of the path verification state N3 that specifies the path ID “4” is updated from “1” to “2”.

  Next, the character string “Carol” is received, the end tag </ name> is received, the end tag </ write> is received, and the start tag <edit> is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . In addition, the cumulative number related to the path ID “6” in the path ID management table T is updated from “1” to “2”, and the automaton A is scanned. Further, the path ID “6” is registered in the frequency management table F. Here, the number of records in the frequency management table F reaches the upper limit. In addition, the node counter of the path verification state N7 that specifies the path ID “6” is updated from “1” to “2”.

  Next, the character string “Dick” is received, the end tag </ name> is received, the end tag </ edit> is received, and the end tag </ news> is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The The scanning position is in the initial state N0.

  Next, the description shifts to the description of FIG. FIG. 36 shows a processing result when each piece of data from the state of FIG. 35 to the middle of the record 3 of the input stream S is received and processed by the collation processing device 100.

  In FIG. 36, the start tag <news> is received, the start tag <date> is received, the character string “2011-12-03” is received, the end tag </ date> is received, and the start tag <write> is received. Is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . In addition, the cumulative number related to the path ID “4” in the path ID management table T is updated from “2” to “3”, and the automaton A is scanned.

  Further, since the frequency management table F has reached the upper limit of the number of records, the oldest path ID “4” is deleted from the frequency management table F, and the path ID “4” is registered in the frequency management table F. Here, the cumulative number of times in the path ID management table T related to the path ID “4” deleted from the frequency management table F is updated from “3” to “2”. The collation processing device 100 performs the same processing on the subsequent character strings of the input stream S. A description of the processing for the subsequent character strings of the input stream S is omitted.

  In the second operation example described above, an example in which the flag of the previous item in the path ID management table T is not used for updating the automaton A is shown, but the present invention is not limited to this. For example, in the second operation example, the previous item of the path ID management table T may be updated by performing the same operation as in the third operation example. Then, as described above, the cumulative number of times of the path ID management table T may be corrected by the frequency management table F, and the automaton A may be updated using the corrected cumulative number of times and the flag.

  In this way, the verification processing device 100 counts the cumulative number that satisfies the query Q condition for each path ID in consideration of the frequency. For example, the matching processing device 100 counts the total number of times that satisfies the condition of the query Q for each path ID in the predetermined number of times detected when the condition of the query Q is satisfied in the past. Therefore, the verification processing apparatus 100 can leave a path verification state that is relatively likely to be scanned again soon, among the path verification states defined in the automaton A. In other words, the matching processing device 100 prevents a path matching state that is relatively likely to be scanned again later from being deleted, and subsequently generating the same path matching state again. be able to. As a result, the matching processing device 100 reduces the load of automaton update processing, suppresses processing delay time caused by generating a path matching state in the automaton A, and speeds up the query Q matching processing using the automaton A. can do.

(Third Operation Example of Collation Processing Device 100)
Next, a third operation example of the verification processing apparatus 100 will be described with reference to FIGS. 37 to 41 are explanatory diagrams illustrating a third operation example of the matching processing device 100. FIG. In the third operation example, the frequency management table F may not be provided. Therefore, the description of the frequency management table F is omitted in FIGS.

  FIG. 37 shows an example of the state of the automaton A in the third operation example. In FIG. 37, the second buffer b2 and the third buffer b3 are empty. Further, the path ID management table T is in the illustrated state. Hereinafter, the processing result when each data of the record 6 is processed by the collation processing device 100 when the record 6 of the input stream S shown in the first buffer b1 is received will be described.

  Next, the description shifts to the description of FIG. FIG. 38 shows a processing result when each data from the state of FIG. 37 to the middle of the record 6 of the input stream S is processed by the collation processing device 100.

  In FIG. 38, the start tag <news> is received, the start tag <date> is received, the character string “2011-12-06” is received, the end tag </ date> is received, and the start tag <write> is received. Is received. Here, each time each data is received, the data obtained by converting each data is written into the second buffer b2 by the verification processing device 100, the third buffer b3 is updated by the current pass, and the automaton A is scanned. The

  Next, when the start tag <name> is received, the collation processing device 100 writes the data obtained by converting the start tag <name> into the second buffer b2, and the third buffer b3 is updated by the current path. . Further, the cumulative number related to the path ID “4” in the path ID management table T is updated from “6” to “7”, and the automaton A is scanned. Further, the node counter in the path verification state N3 that specifies the path ID “4” is updated from “6” to “7”.

  Next, the description shifts to the description of FIG. FIG. 39 shows a process when the start tag <host> of the record 6 of the input stream S is received from the state of FIG.

  In FIG. 39, when the start tag <host> of the input stream S is written to the first buffer b1, the verification processing device 100 reads <host>, converts it to “[9”, and writes it to the second buffer b2. Also, since the start tag <ghost> has been received, the verification processing apparatus 100 writes “/” and the in-tag character string “ghost” at the end of “/ news / write / name” in the third buffer b3.

  Then, the verification processing apparatus 100 registers a record of the path ID “9”, the path “/ news / write / name / host” in the third buffer b3, and the cumulative number “(none)” in the path ID management table T. To do. Here, since the path collation state N3 indicating the path p4 which is the parent path of the path p9 is defined in the automaton A, a transition from the end state N2 to the path collation state N3 is generated and the path ID “4” is related. “Start” is set in the previous item of the path ID management table T.

  Here, the path p9 of the third buffer b3 does not match the query Q condition. Therefore, the collation processing device 100 scans from the initial state N0 that is the scanning position to the start state N1 by “[” of the second buffer b2, and from the start state N1 to the initial state by “9” of the second buffer b2. Scan to N0. Next, the description proceeds to FIG. FIG. 40 shows processing when the start tag <name> of the record 6 of the input stream S is received from the state of FIG.

  In FIG. 40, when the start tag <name> of the input stream S is written to the first buffer b1, the verification processing device 100 reads <name>, converts it to “[10”, and writes it to the second buffer b2. Since the start tag <name> has been received, the verification processing apparatus 100 writes “/” and the character string “name” in the tag at the end of “/ news / write / name / host” in the third buffer b3.

  Then, the verification processing apparatus 100 records in the path ID management table T the path ID “10”, the path “/ news / write / name / host / name” in the third buffer b3, and the cumulative number “(none)”. Register. Here, the path p10 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 updates the cumulative number of records from “(none)” to “1”.

  The path p10 of the third buffer b3 matches the query Q condition. For this reason, the collation processing apparatus 100 updates the automaton A. Specifically, the matching processing device 100 generates a path matching state N15 that identifies the path p10 that satisfies the condition of the query Q. At this time, since the maximum specified number of path verification states are already specified in the automaton A, the verification processing apparatus 100 deletes any path verification status from among the path verification states specified in the automaton A. Then, a path verification state N15 that specifies the path p10 is generated.

  For example, the verification processing apparatus 100 identifies the path ID “4” that minimizes the cumulative number of times in the path ID management table T. However, since “start” is set in the previous item corresponding to the path ID “4”, the path verification state N3 for specifying the path with the path ID “4” is a path verification state to be scanned soon. Therefore, the verification processing apparatus 100 does not delete the path verification state N3 that specifies the path with the path ID “4”.

  Therefore, the verification processing apparatus 100 identifies the path ID “8” with the second smallest cumulative number in the path ID management table T. Next, since “start” is not set in the previous item corresponding to the path ID “8”, the verification processing apparatus 100 deletes the path verification state N11 that specifies the specified path ID “8”.

  Then, the collation processing apparatus 100 includes the keyword collation intermediate states N12 and N13 that are sequentially shifted from the path collation state that specifies the path ID “8” with the deletion of the path collation state N11 that identifies the path ID “8”. The keyword matching completion state N14 is deleted. Next, the matching processing device 100 generates a path matching state N15 that identifies the path p10. Further, when the path matching state N15 that identifies the path p10 is generated, the matching processing device 100 displays the transition destination state that is sequentially shifted from the path matching state N15 that identifies the path p10 by the characters constituting the keyword of the query Q. Generate. The transition destination states are keyword collation intermediate states N16 and N17 and keyword collation completion state N18.

  In addition, the matching processing device 100 generates a transition (not shown) from the path matching state N15 that specifies the path p10 to the start state N1 and a transition (not shown) to the end state N2. The matching processing device 100 also generates a transition (not shown) in which the path matching state N15 that specifies the path p10 loops on itself. This transition is a symbol “Σ \ {[,], B}” obtained by removing the start tag symbol “[”, the end tag symbol “]” and the first character “B” of the keyword from all symbols Σ. Thereby, the first update of the automaton A is completed.

  The verification processing device 100 starts scanning with the updated automaton A. The collation processing device 100 scans from the initial state N0 that is the scanning position to the start state N1 by “[” of “[10” of the second buffer b2, and from the start state N1 by “10” of the second buffer b2. Scan to the path verification state N15 that identifies the path p10. The scanning position is in a path collation state N15 that specifies the path p10.

  When the verification processing device 100 scans the path verification state N15 that specifies the path p10, the node counter of the path verification state N15 that specifies the path p10 is updated from “0” to “1”. Thereafter, the character string “Emily” is received, and the end tag </ name> is received.

  Next, the description proceeds to FIG. FIG. 41 shows the processing when the end tag </ host> of the record 6 of the input stream S is received from the state of FIG.

  In FIG. 41, when the end tag </ host> of the input stream S is written to the first buffer b1, the verification processing device 100 reads </ host>, converts it to “] 9”, and stores it in the second buffer b2. Write. Further, the verification processing device 100 deletes “/” and the in-tag character string “ghost” of the end tag </ host> from the path p9: “/ news / write / name / host” of the third buffer b3, Path p4: Return to “/ news / write / name”. Here, since the path verification state N3 indicating the path p4 is defined in the automaton A, the previous item of the path ID management table T regarding the path ID “4” is updated from “start” to “end”.

  Here, the path p4 of the third buffer b3 matches the query Q condition. For this reason, the collation processing device 100 scans from the initial state N0, which is the scanning position, to the end state N2 by “]” of the second buffer b2, and passes from the end state N2 to the path p4 by “9” of the second buffer b2. To the path verification state N3 that specifies

  In the third operation example described above, the example in which the frequency management table F is not used for updating the automaton A is shown, but the present invention is not limited thereto. For example, in the third operation example, the same operation as in the second operation example is performed to correct the cumulative number of the path ID management table T by the frequency management table F, and the automaton using the corrected cumulative number and flag. A may be updated.

  As described above, when there is a path matching state after scanning from the start state N1 and before scanning from the end state N2, the matching processing device 100 ends the path matching state soon. It is left as it is scanned from state N2. Therefore, the verification processing apparatus 100 can leave a path verification state that is relatively likely to be scanned again soon, among the path verification states defined in the automaton A. In other words, the matching processing device 100 prevents a path matching state that is relatively likely to be scanned again later from being deleted, and subsequently generating the same path matching state again. be able to. As a result, the matching processing device 100 reduces the load of automaton update processing, suppresses processing delay time caused by generating a path matching state in the automaton A, and speeds up the query Q matching processing using the automaton A. can do.

<Hardware Configuration Example of Collation Processing Device 100>
FIG. 42 is a block diagram illustrating a hardware configuration example of the collation processing device 100. In FIG. 42, the collation processing apparatus 100 is a computer configured by connecting a processor 4201, a storage device 4202, an input device 4203, an output device 4204, and a communication device 4205 to a bus 4206.

  The processor 4201 controls the entire computer. In addition, the processor 4201 executes various programs stored in the storage device 4202 to read data in the storage device 4202 and write data as an execution result to the storage device 4202. Examples of the various programs include an OS (Operating System) and an update program according to the present embodiment.

  The storage device 4202 includes a ROM (Read Only Memory), a RAM (Random Access Memory), a flash memory, a magnetic disk drive, and the like. The storage device 4202 becomes a work area of the processor 4201, and is obtained by executing various programs and various programs. Various data including data is stored.

  The input device 4203 is an interface for inputting various data by a user operation such as a keyboard, a mouse, and a touch panel. The output device 4204 is an interface that outputs data in accordance with an instruction from the processor 4201. Examples of the output device 4204 include a display and a printer. The communication device 4205 is an interface that receives data from the outside via the network 101 and transmits data to the outside.

<Example of Functional Configuration of Collation Processing Device 100>
FIG. 43 is a block diagram illustrating a functional configuration example of the collation processing device 100. The verification processing apparatus 100 includes a reading unit 4301, a specifying unit 4302, a detecting unit 4303, a first counting unit 4304, a second counting unit 4305, and an updating unit 4306.

  The collation processing apparatus 100 is a computer that collates the query Q against the input stream S using the automaton A. Here, the input stream S is a data string that is hierarchized by tags, and is a data string that is received from the computer that is the source G via the network 101. The input stream S is, for example, XML data as shown in FIG. The input stream S may be, for example, HTML data.

  A tag is information indicating a position where a set of elements exists, and is, for example, a start tag or an end tag. The position is, for example, a hierarchy in the input stream S. The start tag is information indicating the start position of the set of elements, and is, for example, the start tag <news> or the start tag <name> shown in FIG. The end tag is information indicating the end position of the set of elements, and is, for example, the end tag </ news> or the end tag </ name> shown in FIG. The element is a character string included between the start tag and the end tag, another start tag, or another end tag.

  The query Q is information including a keyword and a path condition corresponding to the keyword. The keyword is a character string that is collated with the character string of the input stream S, and is, for example, the character string “Bob” illustrated in FIG. The path is information indicating the position of an arbitrary tag, and is a path from the top layer of the input stream S to the layer indicated by the arbitrary tag. For example, the path of the start tag <news> shown in FIG. 2 is a path “/ news” from the root indicating the 0th hierarchy, which is the highest hierarchy, to the first hierarchy indicated by the start tag <news>. The path condition is a path condition indicating a hierarchy in which the keyword exists, and is, for example, “/ news // name” illustrated in FIG.

  “/ News // name” indicates the path of the root of the 0th layer → the first layer “news” → the arbitrary layer “name”. Therefore, for example, the path “/ news / name”, the path “/ news / write / name”, the path “/ news / name / write / name”, and the like satisfy the conditions of the path corresponding to the keyword in the query Q.

  The automaton A is information defining, for example, at least an initial state, a start state indicating a start tag symbol, and an end state indicating an end tag symbol. The automaton A may further include a plurality of path collation states indicating paths that satisfy the condition, and a keyword collation intermediate state and a keyword collation completion state are defined as transition destination states from the path collation state. Also good.

  The reading unit 4301 reads the input stream S from the top. For example, as illustrated in FIG. 11, the reading unit 4301 receives <news> when the start tag <news>, which is the first data of the record 1 of the input stream S, is received and written to the first buffer b1. Then, the reading unit 4301 converts the read start tag <news> into “[1” and writes it in the second buffer b2.

  The reading unit 4301 realizes its function by causing the processor 4201 to execute a program stored in the storage device 4202 illustrated in FIG. 42, for example. Thereby, the reading unit 4301 can read data to be processed by the specifying unit 4302.

  When the start tag in the input stream S is read by the reading unit 4301, the specifying unit 4302 specifies a path from the highest layer of the input stream S to the layer indicated by the start tag. For example, when the start tag <news> is received and written to the second buffer by the reading unit 4301, the specifying unit 4302 specifies the current path “/ news” and writes it to the third buffer b3. If the identified path is not registered in the path ID management table T, the identifying unit 4302 stores the path ID “1” and the path “/” in the third buffer b3 in the path ID management table T. records of “news”, cumulative number of times “(none)”, and flag “(none)” are registered.

  Further, when the reading unit 4301 reads the end tag in the input stream S, the specifying unit 4302 specifies a path indicating an upper layer of the layer indicated by the current path. For example, when the end tag </ news> is received and written to the second buffer by the reading unit 4301, the specifying unit 4302 obtains the current path “/ news” written to the third buffer. Next, the identifying unit 4302 deletes “/” and the in-tag character string “news” of the end tag </ news> from the acquired current path “/ news”, and the 0th hierarchy that is the upper hierarchy. The path “(None)” indicating is written to the third buffer b3.

  The specifying unit 4302 realizes its function by causing the processor 4201 to execute a program stored in the storage device 4202 illustrated in FIG. 42, for example. Thus, the detection unit 4303 can acquire the path specified by the specifying unit 4302 and determine whether or not the path condition of the query Q is satisfied.

  The detection unit 4303 detects a path that satisfies the condition by determining whether the path specified by the specifying unit 4302 satisfies the condition. For example, when the path specified by the specifying unit 4302 is “/ news”, the detection unit 4303 determines that the path condition “/ news // name” is not satisfied, and does not detect it. On the other hand, for example, when the path specified by the specifying unit 4302 is “/ news / name”, the detection unit 4303 determines that the path condition “/ news // name” is satisfied, and the path “ / News / name "is detected.

  The detection unit 4303 realizes its function by causing the processor 4201 to execute a program stored in the storage device 4202 illustrated in FIG. 42, for example. Accordingly, the first counting unit 4304 can count the cumulative number of times that the path is detected by the detecting unit 4303.

  The first counting unit 4304 counts the number of detections for each path that satisfies the condition every time the detection unit 4303 detects a path that satisfies the condition from the input stream S. For example, if the detection unit 4303 detects the path “/ news / name” indicated by the start tag, the first counting unit 4304 accumulates corresponding to the path “/ news / name” in the path ID management table T. Increment the number of times. On the other hand, when the detection unit 4303 detects the path “/ news / name” indicated by the end tag, the first counting unit 4304 corresponds to the path “/ news / name” in the path ID management table T. It is not necessary to increment the cumulative number.

  In addition, when the detection unit 4303 detects the path “/ news / name” indicated by the start tag, the first counting unit 4304 has a flag corresponding to the path “/ news / name” in the path ID management table T. Set to “Start”. For example, when the detection unit 4303 detects the path “/ news / name” indicated by the end tag, the first counting unit 4304 has a flag corresponding to the path “/ news / name” in the path ID management table T. Set to “End”. The first counting unit 4304 may count the number of detections for each path that satisfies the condition among the number of detections of the path that satisfy the latest predetermined number of times. For example, the first counting unit 4304 corrects the cumulative number of times in the path ID management table T by the frequency management table F as described above.

  The first counting unit 4304 realizes its function by causing the processor 4201 to execute a program stored in the storage device 4202 illustrated in FIG. 42, for example. Accordingly, the update unit 4306 can update the automaton A based on the number of detections counted by the first counting unit 4304.

  The second counting unit 4305 counts the number of times of transition from the start state to the path matching state for each path matching state defined in the automaton A. When the automaton A is scanned by the matching processing device 100 and a transition is made to the path matching state defined in the automaton A, the second counting unit 4305 increments the node counter in the path matching state in which the transition has been performed. To do.

  For example, the second counting unit 4305 realizes its function by causing the processor 4201 to execute a program stored in the storage device 4202 illustrated in FIG. 42. Accordingly, the update unit 4306 can update the automaton A based on the number of transitions counted by the second counting unit 4305.

  The update unit 4306 updates the automaton A based on the counted number of detections when adding a new path matching state indicating a path that satisfies the condition to the automaton A. The update unit 4306 updates the automaton A when, for example, there are a predetermined number or more of path collation states defined in the automaton A. Specifically, the update unit 4306 deletes a path matching state indicating a path satisfying a condition with a relatively small number of detected counts among the path matching states defined in the automaton A.

  In addition, when the update unit 4306 detects a path satisfying the condition and the number of path matching states defined in the automaton A is smaller than a predetermined number, the update unit 4306 sets the path matching state indicating the detected path to the automaton. By adding to A, automaton A is updated.

  The process of deleting the path matching state described above from the automaton A and the process of adding the path matching state described above to the automaton A may be executed first or the process of adding may be performed. It may be the destination. The update unit 4306 realizes its function by causing the processor 4201 to execute a program stored in the storage device 4202 illustrated in FIG. 42, for example. As a result, the update unit 4306 can realize the first operation example of the verification processing apparatus 100.

  Further, the update unit 4306 deletes one of the first and second path matching states having the same counted number of detections among the path matching states defined in the automaton A based on the counted number of transitions. Accordingly, the automaton A may be updated. Thereby, the update unit 4306 can realize the second operation example of the verification processing apparatus 100.

  The update unit 4306 updates the automaton A when, for example, there are a predetermined number or more of path collation states defined in the automaton A. Specifically, the update unit 4306 is in a path matching state defined in the automaton A, and among the path matching states in which the end tag corresponding to the read start tag is read, the counted number of detections is relative. Delete path verification states that indicate fewer paths. Thereby, the update unit 4306 can realize the third operation example of the verification processing apparatus 100.

<Update procedure>
FIG. 44 is a flowchart illustrating an example of a processing procedure of update processing of the verification processing device 100.

  First, the verification processing apparatus 100 determines whether or not there is an initial automaton A0 (step S4401). When there is no initial automaton A0 (step S4401: No), the collation processing apparatus 100 executes initialization (step S4402). In initialization, the verification processing device 100 empties the path ID management table T in the storage device.

  Next, the matching processing device 100 executes an initial automaton construction process (step S4403), and proceeds to step S4405. In the initial automaton construction process (step S4403), the initial automaton A0 is constructed. The initial automaton construction process (step S4403) will be described later with reference to FIG.

  On the other hand, if there is an initial automaton A0 (step S4401: YES), the verification processing apparatus 100 acquires the initial automaton A0 from the storage device (step S4404), and proceeds to step S4405. In step S4405, the collation processing apparatus 100 determines the initial automaton A0 as the automaton A to be scanned (step S4405).

  Thereafter, the verification processing apparatus 100 waits for the input stream S (step S4406: No). When the input stream S is received (step S4406: YES), the collation processing apparatus 100 sets the head position of the input stream S to the current reading position Scur (step S4407).

  Then, the verification processing apparatus 100 determines whether the data at the current reading position Scur is a start tag, a character, or an end tag (step S4408). If it is a start tag (step S4408: start tag), the collation processing apparatus 100 executes the first scanning process (step S4409) and returns to step S4408. Details of the first scanning process (step S4409) will be described later with reference to FIG.

  If it is a character (step S4408: character), the collation processing apparatus 100 executes the second scanning process (step S4410) and returns to step S4408. Details of the second scanning process (step S4410) will be described later with reference to FIG.

  If it is an end tag (step S4408: end tag), the collation processing device 100 executes a third scanning process (step S4411) and returns to step S4408. Details of the third scanning process (step S4411) will be described later with reference to FIG.

  On the other hand, in step S4408, when there is no current reading position Scur (step S4408: none), the collation processing device 100 determines whether or not a certain time has elapsed since there is no current reading position (step S4412). ). If the predetermined time has not elapsed (step S4412: NO), the process returns to step S4408. As a result, data reception of the input stream S is awaited. On the other hand, when the fixed time has elapsed (step S4412: Yes), the matching processing device 100 ends the update process.

<Initial automaton construction process>
FIG. 45 is a flowchart showing an example of the processing procedure of the initial automaton construction process (step S4403) shown in FIG.

  The verification processing device 100 creates an initial state N0, a start state N1, and an end state N2 (step S4501), and sets the initial value of the created transition destination of each state to the initial state N0 (step S4502). As a result, the initial automaton A0 is constructed as shown in FIG. The constructed initial automaton A0 is stored in the storage device.

<First scanning process>
FIG. 46 is a flowchart illustrating an example of a processing procedure of the first scanning process (step S4409) illustrated in FIG.

  The verification processing apparatus 100 performs binary conversion on the read start tag (step S4601). For example, as shown in FIG. 3, when the start tag <news> is read, it is converted to "[1".

  The verification processing apparatus 100 adds “/ t” to the current path p (step S4602). “/” Is a symbol indicating a hierarchy boundary. t is a character string in the tag. For example, when the start tag <news> is read, p becomes p = / news. When the current path is “/ news / write” and the start tag <name> is read, p becomes p = / news / write / name.

  Then, the verification processing device 100 refers to the path ID management table T and determines whether or not the current path p exists in the path ID management table T (step S4603). If the current path p is present in the path ID management table T (step S4603: YES), the process proceeds to step S4608.

  On the other hand, when there is no current path p in the path ID management table T (step S4603: No), the verification processing apparatus 100 adds the current path p to the path ID management table T and adds a new path to the path p. An ID is assigned (step S4604). For example, when the start tag <news> is read while the path ID management table T is empty, the path ID “1” and the path p = / news are added.

  Then, the verification processing apparatus 100 determines whether or not the current path p matches the query Q condition (step S4605). If a match is found (step S4605: YES), the collation processing device 100 executes the first update process (step S4606), and proceeds to step S4608. Details of the first update process (step S4606) will be described later with reference to FIG.

  On the other hand, when there is no match (step S4605: No), the collation processing device 100 executes the second update process (step S4607), and proceeds to step S4608. Details of the second update process (step S4607) will be described later with reference to FIG.

  Next, the collation processing device 100 makes a transition for “[i” from the current reading position Acur of the automaton A to be scanned, and sets the transition destination to a new reading position Acur (step S4608). i is a path ID corresponding to p. Then, the verification processing device 100 executes the cumulative number update process (step S4609). Details of the cumulative number update process will be described later with reference to FIG.

  Next, the verification processing apparatus 100 sets “start” in the previous item corresponding to the current path ID in the path ID management table T (step S4610). Then, the verification processing apparatus 100 adds the current reading position Scur of the input stream S by the character string length of the start tag to update the current reading position Scur (step S4611), and ends the first scanning process.

<First update process>
FIG. 47 is a flowchart illustrating an example of a processing procedure of the first update processing (step S4606) illustrated in FIG.

  The verification processing apparatus 100 determines whether or not a new state can be added to the automaton A (step S4701). Here, when it cannot add (step S4701: No), the collation processing apparatus 100 performs a deletion process (step S4702), and transfers to step S4703. Details of the deletion process will be described later with reference to FIG. On the other hand, when it can add (step S4701: Yes), collation processing device 100 shifts to step S4703.

  In step S4703, the matching processing apparatus 100 creates a path matching state V corresponding to the path ID “i” (step S4703). Next, the verification processing apparatus 100 sets the transition destination related to “[” from the created path verification status V to the start state N1, and sets the transition destination related to “]” to the end state N2. Then, the matching processing device 100 sets itself as the other transition destination from the created path matching state V (step S4704).

  Next, the verification processing device 100 changes the transition destination for the path ID “i” in the start state N1 from the initial state N0 to the path verification state V (step S4705). In addition, the matching processing device 100 creates a keyword state related to the keyword k in the query Q and sets a transition between the keyword states (step S4706). The keyword state is a transition destination state when each character of the keyword is transitioned, and is, for example, a keyword collation intermediate state N4, N5 and a keyword collation completion state N6.

  Next, the matching processing device 100 sets a transition from the path matching state V to a state corresponding to the first character of the keyword k (step S4707). Then, the matching processing device 100 sets the state corresponding to the last character of the keyword k as the keyword matching completion state N6 (step S4708). As a result, as shown in FIG. 16, the initial automaton A0 is updated to the automaton A1.

<Delete processing>
FIG. 48 is a flowchart illustrating an example of a processing procedure of the deletion process (step S4702) illustrated in FIG.

  The verification processing apparatus 100 acquires the path verification status defined in the current automaton A, and acquires a set S of path IDs specified by the path verification status (step S4801). Next, the verification processing device 100 identifies a path ID that minimizes the cumulative number of times in the path ID management table T in the set S (step S4802).

  Then, the verification processing apparatus 100 determines whether there are two or more specified path IDs (step S4803). Here, when there is one path ID (step S4803: No), the verification processing apparatus 100 proceeds to step S4806.

  On the other hand, when there are two or more path IDs (step S4803: Yes), the collation processing apparatus 100 identifies a path ID that minimizes the node counter among the identified two or more path IDs (step S4804). . Next, the verification processing device 100 randomly specifies one path ID among the specified path IDs (step S4805). Then, the verification processing apparatus 100 proceeds to step S4806.

  In step S4806, the matching processing device 100 deletes the path matching status that identifies the identified path ID (step S4806). Next, the verification processing apparatus 100 ends the deletion process.

<Second update process>
FIG. 49 is a flowchart illustrating an example of a processing procedure of the second update process (step S4607) illustrated in FIG.

  The verification processing apparatus 100 sets a path obtained by removing the last tag “/ t” from the current path p as a path par, and sets a path ID corresponding to the path par as j (step S4901).

  Next, the matching processing device 100 determines whether or not the path matching state for specifying the path ID “j” is defined in the automaton A (step S4902). Here, when not prescribed | regulated (step S4902: No), the collation processing apparatus 100 complete | finishes a 2nd update process.

  On the other hand, when defined (step S4902: Yes), the verification processing device 100 sets the path verification state N3 corresponding to the path ID “j” to w (step S4903), and sets the transition destination for i in the end state N2. Then, the initial state N0 is changed to the path verification state w (step S4904). Accordingly, as shown in FIG. 20, the automaton A is updated from the automaton A1 to the automaton A2.

<Cumulative number update process>
FIG. 50 is a flowchart illustrating an example of a processing procedure of the cumulative number updating process (step S4609) illustrated in FIG.

  The verification processing apparatus 100 determines whether Acur is in the path ID verification state (step S5001). Here, when it is not in the path ID collation state (step S5001: No), the collation processing apparatus 100 ends the cumulative number update process.

  On the other hand, when it is in the path ID collation state (step S5001: Yes), the collation processing apparatus 100 updates the Acur node counter (step S5002). Next, the verification processing apparatus 100 updates the cumulative number corresponding to the Acur path ID in the path ID management table T (step S5003).

  Then, the verification processing device 100 determines whether or not there is a free area in the frequency management table F (step S5004). Here, when there is no free space (step S5004: No), the collation processing apparatus 100 acquires the top data of the frequency management table F (step S5005). Next, the verification processing apparatus 100 updates the cumulative number corresponding to the path ID indicated by the head data in the path ID management table T (step S5006). Then, the verification processing apparatus 100 proceeds to step S5007.

  On the other hand, when there is a free area (step S5004: Yes), the verification processing apparatus 100 proceeds to step S5007. In step S5007, the verification processing apparatus 100 adds the Acur path ID as tail data to the frequency management table F (step S5007). Here, when the number of records in the frequency management table F has reached the upper limit, the head data is deleted when the path ID is added as the tail data. Then, the verification processing device 100 ends the cumulative number update process.

<Second scanning process>
FIG. 51 is a flowchart showing an example of the processing procedure of the second scanning process (step S4410) shown in FIG.

  The verification processing device 100 makes a transition for the character read this time from the current reading position Acur of the automaton A, and sets the transition destination to a new Acur (step S5101). In the following description, the character read this time may be referred to as “character c”. Then, the matching processing device 100 determines whether or not the state indicated by the current reading position Acur is the keyword matching completed state N6 (step S5102).

  When it is the keyword collation completion state N6 (step S5102: Yes), the collation processing apparatus 100 outputs the keyword k of the query Q that becomes the query Q collation result Ans (step S5103), and proceeds to step S5104.

  On the other hand, when it is not the keyword matching completion state N6 (step S5102: No), the process proceeds to step S5104. In step S5104, the collation processing apparatus 100 updates the current reading position Scur of the input stream S to Scur = Scur + 1 (step S5104). That is, the verification processing apparatus 100 advances the reading position Scur for one character. Thus, the second scanning process (step S4410) is terminated.

<Third scanning process>
FIG. 52 is a flowchart showing an example of the processing procedure of the third scanning process (step S4411) shown in FIG.

  The verification processing apparatus 100 performs binary conversion on the read end tag (step S5201). For example, as shown in FIG. 3, when the end tag </ news> is read, it is converted to "] 1".

  The verification processing device 100 makes a transition from the current reading position Acur of the automaton A to “] i”, and sets the transition destination to a new reading position Acur (step S5202). i is a path ID corresponding to p. If the previous item regarding the current path ID is “start”, the verification processing apparatus 100 updates it to “end” (step S5203).

  Next, the verification processing apparatus 100 updates the current reading position Scur by adding the current reading position Scur of the input stream S by the character string length of the end tag (step S5204). Then, the collation processing device 100 sets a path obtained by deleting “/ t” from the end of the current path p as a new path p (step S5205), and ends the third scanning process.

  As described above, according to the matching processing device 100, every time a path satisfying the query Q condition is detected in the matching process, the number of detections for each path satisfying the query Q is counted, and the automaton A is based on the number of detections. Can be updated. Thereby, the collation processing apparatus 100 can grasp the path collation state that is highly likely to be scanned later among the path collation states defined in the automaton A, and can update the automaton A.

  For example, according to the matching processing device 100, the path matching state indicating the path with the smallest number of detections can be deleted. As a result, the verification processing apparatus 100 can leave a path verification state that is relatively likely to be scanned again later among the path verification states defined in the automaton A. In other words, the matching processing device 100 prevents a path matching state that is relatively likely to be scanned again later from being deleted, and subsequently generating the same path matching state again. be able to. As a result, the matching processing device 100 reduces the load of automaton update processing, suppresses processing delay time caused by generating a path matching state in the automaton A, and speeds up the query Q matching processing using the automaton A. can do.

  Further, for example, according to the matching processing device 100, even if there are first and second path matching states indicating the first and second paths having the same number of detections, the path matching state with a small node counter is deleted. be able to. As a result, the verification processing apparatus 100 can leave a path verification state that is relatively likely to be scanned again later among the path verification states defined in the automaton A. In other words, the matching processing device 100 prevents a path matching state that is relatively likely to be scanned again later from being deleted, and subsequently generating the same path matching state again. be able to. As a result, the matching processing device 100 reduces the load of automaton update processing, suppresses processing delay time caused by generating a path matching state in the automaton A, and speeds up the query Q matching processing using the automaton A. can do.

  Further, for example, according to the matching processing device 100, the path matching status with the smallest number of detections can be deleted from among the path matching statuses indicating the paths whose previous item flag is “finished”. Thereby, the collation processing apparatus 100 leaves the automaton A in a path collation state scanned from the end state N2 in the near future. Therefore, the verification processing apparatus 100 can leave a path verification state that is relatively likely to be scanned again soon, among the path verification states defined in the automaton A. In other words, the matching processing device 100 prevents a path matching state that is relatively likely to be scanned again later from being deleted, and subsequently generating the same path matching state again. be able to. As a result, the matching processing device 100 reduces the load of automaton update processing, suppresses processing delay time caused by generating a path matching state in the automaton A, and speeds up the query Q matching processing using the automaton A. can do.

  Further, for example, according to the verification processing apparatus 100, the cumulative number of times of the path ID management table T can be corrected by the frequency management table F. Thereby, the collation processing apparatus 100 can count the cumulative number that satisfies the condition of the query Q for each path ID in consideration of the frequency. For example, the verification processing apparatus 100 can count the cumulative number of times that satisfy the query Q condition for each path ID among the predetermined number of times detected when the query Q condition is satisfied in the past.

  The following additional notes are disclosed with respect to the embodiment described above.

(Additional remark 1) The computer which collates the query containing the keyword and the conditions of the path | pass corresponding to the said keyword with respect to the input stream hierarchized by the tag using an automaton,
Each time a path satisfying the condition is detected from the input stream, the number of detections for each path satisfying the condition is counted,
An automaton in which an initial state, a start state indicating a start tag symbol, and an end state indicating an end tag symbol are defined, and a plurality of path matching states indicating paths satisfying the condition are indicated, indicates a path satisfying the condition. When adding a new path matching state, the automaton is updated based on the number of detections for each path that satisfies the counted condition.
An update method characterized by executing processing.

(Appendix 2) The update process is as follows:
When there are a predetermined number or more of path matching states defined for the automaton, among path matching states defined for the automaton, a path matching state indicating a path satisfying the condition with a relatively small number of detected counts. The update method according to appendix 1, wherein the automaton is updated by deleting.

(Supplementary note 3)
Read the input stream from the beginning,
When the start tag in the input stream is read, the path from the top layer of the input stream to the layer indicated by the start tag is specified,
Detecting a path that satisfies the condition by determining whether or not the identified path satisfies the condition,
The counting process is:
If a path that satisfies the condition is detected, the number of detections of the detected path that satisfies the condition is counted,
The update process is as follows:
If there are a predetermined number or more of path matching states defined in the automaton, the path matching state defined in the automaton is a path matching state in which an end tag corresponding to the read start tag is read. Updating the automaton by deleting a path matching state indicating a path with a relatively small number of detected counts,
The update method according to appendix 1 or 2, characterized in that:

(Appendix 4) The update process is as follows:
When a path satisfying the condition is detected and the number of path matching states defined in the automaton is less than a predetermined number, a path matching state indicating a path that satisfies the detected condition is added to the automaton. To update the automaton,
The update method according to any one of appendices 1 to 3, wherein:

(Appendix 5) The computer
For each path matching state defined in the automaton, execute a process of counting the number of transitions made from the start state to the path matching state,
The update process is as follows:
Based on the counted number of transitions, the automaton is updated by deleting one of the first and second path matching states with the same number of detected counts among the path matching states defined for the automaton. The update method according to any one of appendices 1 to 4, wherein:

(Supplementary Note 6) The process of counting the number of detections is performed every time a path satisfying the condition is detected, the number of detections for each path satisfying the condition among the latest predetermined number of detections of the path satisfying the condition. The update method according to any one of appendices 1 to 5, wherein the update method is counted.

(Supplementary Note 7) A computer that performs matching of a query including a keyword and a path condition corresponding to the keyword on an input stream hierarchized by tags using an automaton,
Each time a path satisfying the condition is detected from the input stream, the number of detections for each path satisfying the condition is counted,
An automaton in which an initial state, a start state indicating a start tag symbol, and an end state indicating an end tag symbol are defined, and a plurality of path matching states indicating paths satisfying the condition are indicated, indicates a path satisfying the condition. When adding a new path matching state, the automaton is updated based on the number of detections for each path that satisfies the counted condition.
An update program characterized by causing a process to be executed.

(Supplementary note 8) A collation processing device for collating a query including a keyword and a path condition corresponding to the keyword against an input stream hierarchized by a tag using an automaton,
A counter that counts the number of detections for each path that satisfies the condition each time a path that satisfies the condition is detected from the input stream;
An automaton in which an initial state, a start state indicating a start tag symbol, and an end state indicating an end tag symbol are defined, and a plurality of path matching states indicating paths satisfying the condition are indicated, indicates a path satisfying the condition. When adding a new path verification state, an updating unit that updates the automaton based on the number of detections for each path that satisfies the condition counted by the counting unit;
The collation processing apparatus characterized by having.

DESCRIPTION OF SYMBOLS 100 Collation processing apparatus 4301 Reading part 4302 Identification part 4303 Detection part 4304 1st counting part 4305 2nd counting part 4306 Update part A Automaton T Path ID management table

Claims (6)

A computer that performs matching of a query including a keyword and a path condition corresponding to the keyword with respect to an input stream layered by tags using an automaton,
Each time a path satisfying the condition is detected from the input stream, the number of detections for each path satisfying the condition is counted,
An automaton in which an initial state, a start state indicating a start tag symbol, and an end state indicating an end tag symbol are defined, and a plurality of path matching states indicating paths satisfying the condition are indicated, indicates a path satisfying the condition. When adding a new path matching state, the automaton is updated based on the number of detections for each path that satisfies the counted condition.
An update method characterized by executing processing. The update process is as follows:
When there are a predetermined number or more of path matching states defined for the automaton, among path matching states defined for the automaton, a path matching state indicating a path satisfying the condition with a relatively small number of detected counts. The update method according to claim 1, wherein the automaton is updated by deleting. The computer is
Read the input stream from the beginning,
When the start tag in the input stream is read, the path from the top layer of the input stream to the layer indicated by the start tag is specified,
Detecting a path that satisfies the condition by determining whether or not the identified path satisfies the condition,
The counting process is:
If a path that satisfies the condition is detected, the number of detections of the detected path that satisfies the condition is counted,
The update process is as follows:
If there are a predetermined number or more of path matching states defined in the automaton, the path matching state defined in the automaton is a path matching state in which an end tag corresponding to the read start tag is read. Updating the automaton by deleting a path matching state indicating a path with a relatively small number of detected counts,
The update method according to claim 1 or 2, characterized in that: The computer is
For each path matching state defined in the automaton, execute a process of counting the number of transitions made from the start state to the path matching state,
The update process is as follows:
Based on the counted number of transitions, the automaton is updated by deleting one of the first and second path matching states with the same number of detected counts among the path matching states defined for the automaton. The update method according to claim 1, wherein the update method is performed. Using an automaton, to a computer that performs matching of a query including a keyword and a path condition corresponding to the keyword against an input stream hierarchized by tags,
Each time a path satisfying the condition is detected from the input stream, the number of detections for each path satisfying the condition is counted,
An automaton in which an initial state, a start state indicating a start tag symbol, and an end state indicating an end tag symbol are defined, and a plurality of path matching states indicating paths satisfying the condition are indicated, indicates a path satisfying the condition. When adding a new path matching state, the automaton is updated based on the number of detections for each path that satisfies the counted condition.
An update program characterized by causing a process to be executed. A matching processing device that performs matching of a query including a keyword and a path condition corresponding to the keyword against an input stream hierarchized by tags using an automaton,
A counter that counts the number of detections for each path that satisfies the condition each time a path that satisfies the condition is detected from the input stream;
An automaton in which an initial state, a start state indicating a start tag symbol, and an end state indicating an end tag symbol are defined, and a plurality of path matching states indicating paths satisfying the condition are indicated, indicates a path satisfying the condition. When adding a new path verification state, an updating unit that updates the automaton based on the number of detections for each path that satisfies the condition counted by the counting unit;
The collation processing apparatus characterized by having.

Images