JP5320697B2 - Collation processing program and collation processing apparatus - Google Patents

Abstract

A collation processing device has a document storage unit, axis transforming unit, automaton creating unit, and collating processing unit. The document storage unit stores document data having a hierarchical structure in which elements are sectioned by element identifiers. The axis transforming unit executes axis transformation on a search formula when the search formula is obtained, whereby the search formula concerned is transformed to a search formula constructed of child axes. The automaton creating unit identifies the type of element identifiers contained in the transformed search formula to create the automaton corresponding to the search formula concerned. The collating processing unit collates data contained in the document data with the automaton to output the data corresponding to the search formula.

Description

  The present invention relates to a collation processing program for retrieving data corresponding to a search expression from document data having a hierarchical structure in which elements are separated by element identifiers. In particular, the data is searched from document data regardless of the structure of the search expression. It is related with the collation processing program etc. which can be performed.

  In recent years, XML (Extensible Markup Language) or the like is used as document data processed by a computer. This XML includes a hierarchical structure using element identifiers "<" and "/>" that are referred to as tags, and can contain more information than text format. (Hereinafter, document data having a hierarchical structure described based on XML is referred to as XML data).

  In order to efficiently search XML data including a hierarchical structure, a method of searching for document data and nodes corresponding to the query is generally used by using a search expression such as a query (Xpath expression). (For example, refer to Patent Document 1).

JP 2004-126933 A

  However, as XML data grows larger and larger, it is required to search for documents and nodes corresponding to the query based on stream processing without putting a load on the computer. Is included, there is a problem that it is difficult to search XML data by stream processing.

  FIG. 34 is a diagram for explaining the problems of the prior art. Explaining why it is difficult to retrieve XML data by stream processing, stream-oriented processing cannot reread already read data, but if the query includes a retrograde axis, This is because it is necessary to access past data (D1 to Dn-1 in FIG. 34) rather than the data position (Dn in FIG. 34).

  That is, even if the query includes a branch or the like, it is a very important issue to search the document data corresponding to the query from the XML data at high speed and efficiently.

  The present invention has been made to solve the above-described problems caused by the prior art, and is a collation capable of quickly and efficiently retrieving document data corresponding to a query from XML data, regardless of the structure of the query. An object is to provide a processing program and a verification processing device.

  In order to solve the above-described problems and achieve the object, the present invention provides a computer with a document storage procedure for storing document data having a hierarchical structure in which elements are separated by element identifiers in a storage device, and storing the document data in the storage device. Axis conversion procedure to perform axis conversion on the acquired search expression and convert the search expression to a search expression composed of child axes when a search expression for searching data included in the document data is acquired Automaton creation procedure for identifying the type of element identifier included in the search expression converted by the axis conversion procedure and creating an automaton corresponding to the search expression, data included in the document data, and the automaton. And a collation process procedure for collating in order and outputting data corresponding to the search formula.

  Further, the present invention is the above invention, wherein the axis conversion procedure determines whether or not a sibling axis exists in the search formula, and when the sibling axis exists, the sibling axis is set as a parent axis. It is characterized by converting to a child axis.

  In the above invention, the axis conversion procedure determines whether or not a parent axis exists in the search formula, and when the parent axis exists, converts the parent axis to a child axis. That is, “conversion of parent axis to child axis” can be handled as an example of axis conversion. For example, Reference 1 (D. Olteanu et al., “XPath: Looking Forward”, Proc.XMLDM'02 , 2002.).

  In the above invention, the search expression includes a predicate part that is a constraint condition, and the axis conversion procedure maintains the relationship between the search expression before conversion and the search expression after conversion at the same value. Change the position of the predicate part included in the expression.

  Also, in the present invention, in the above invention, the collation processing procedure sequentially stores data detected in the process of collating data included in the document data and the automaton in order in a temporary storage table. The data stored in the temporary storage table is output at the time of termination.

  According to the present invention, when storing document data having a hierarchical structure in which elements are separated by element identifiers in a storage device, and obtaining a search expression for searching for data included in the document data stored in the storage device, Axis conversion is performed on the acquired search expression, the search expression is converted into a search expression constituted by child axes, and the type of element identifier included in the converted search expression is identified to correspond to the search expression An automaton is created, and the data contained in the document data and the automaton are collated in order, and the data corresponding to the search expression is output. Therefore, the data corresponding to the search expression can be quickly retrieved from the document data regardless of the structure of the search expression. You can search efficiently.

  Further, according to the present invention, it is determined whether or not a sibling axis exists in the search expression. When the sibling axis exists, the sibling axis is converted into a parent axis and a child axis. By processing, data corresponding to the search expression can be efficiently searched.

  Further, according to the present invention, it is determined whether or not a parent axis exists in the search formula, and when the parent axis exists, the parent axis is converted into a child axis. Data corresponding to the expression can be searched efficiently. As an example of axis conversion, “transform parent axis to child axis” can be handled. As an implementation method, for example, Reference 1 (D. Olteanu et al., “XPath: Looking Forward”, Proc. XMLDM'02, 2002 .)

  In addition, according to the present invention, the position of the predicate part included in the search expression is changed while maintaining the relationship between the search expression before conversion and the search expression after conversion at the same value. You can search efficiently.

  In addition, according to the present invention, data detected in the process of sequentially collating data contained in document data and an automaton is sequentially stored in the temporary storage table, and stored in the temporary storage table when the collation is completed. Therefore, data corresponding to a search expression including a branch can be output efficiently.

  Exemplary embodiments of a verification processing program and a verification processing device according to the present invention will be described below in detail with reference to the accompanying drawings.

  First, the reverse axis of the XML data and query will be described. FIG. 1 is a diagram illustrating a tree representation of XML data and a stream representation of XML data, and FIG. 2 is a diagram illustrating an example of a query (search expression) including a reverse axis.

  As shown in FIG. 1, in the tree representation of XML data, the XML data has elements of papers10, paper11, 12, author13, 16, and title14, 15, and connects these elements.

  Specifically, papers 10 is connected to papers 11 and 12, paper 11 is connected to author 13 and title 14, and paper 12 is connected to title 15 and author 16. Authors 13 and 16 are connected to document data “asai”, title 14 is connected to document data “XML”, and title 15 is connected to document data “Data Stream”.

  Here, the relationship between papers 10 and papers 11 and 12 is defined as a parent and a child. Also, the relationship between papers 11 and 12 is defined as a brother, paper 11 is defined as an elder brother, and paper 12 is defined as a younger brother. Similarly, the relationship between paper 11 and author 13 and title 14 is defined as a parent and a child. Further, the relationship between author13 and title14 is defined as a brother, author13 is defined as an elder brother, and title14 is defined as a younger brother.

  Further, the relationship between paper 12 and title 15 and author 16 is defined as a parent and a child. The relationship between title15 and author16 is defined as a brother, title15 is defined as an elder brother, and author16 is defined as a younger brother. In addition, an element connected to the lower side of each element is defined as a descendant. For example, the descendants of papers10 are paper11, 12, author13, 16, title14, 15.

  In the stream representation of XML data, each element is arranged in order from the left axis of the tree representation of XML data. In the case of performing a data search by a query with respect to the XML data represented by this stream expression, there is an advantage that the memory usage is small and it is easy to deal with huge data, but already read data cannot be read again. For example, in the stream-represented XML data, (open, author) (text, “asai”) cannot be read after (open, title) (text, “XML”) is referenced.

  Subsequently, when shifting to the explanation of FIG. 2, the meaning of the query shown in FIG. 2 is to search for the title element directly under the papers under the constraint condition [../author=“asai ”]. Meaning. In the case of FIG. 2, the constraint condition [../author=“asai ”] means that there is an author having document data“ asai ”directly under the parent of the title element (in this case, paper). It is a constraint condition.

  The elements searched by the query of FIG. 2 are title14 and title15 of FIG. 1, and the search results as shown in FIG. 3 are displayed. FIG. 3 is a diagram showing a search result when the XML data of FIG. 1 is searched by the query shown in FIG.

  However, since the query shown in FIG. 2 needs to refer to the parent axis paper of the title after referring to the title once (including the retrograde axis), the XML data in FIG. There is a problem that it is difficult to do. In the example shown in FIG. 2, “../” represents the retrograde axis.

  Next, a verification processing apparatus according to the present embodiment will be described. The collation processing apparatus according to the present embodiment performs the axis conversion on the query including the retrograde axis and the branch as described above based on the axis conversion algorithm, and searches the XML data by the stream processing using the axis converted query. Execute. As described above, since the collation processing apparatus according to the present embodiment performs the search of the XML data by the stream processing after performing the axis conversion of the query, the document corresponding to the query from the XML data regardless of the configuration of the query. Data and the like can be searched quickly and efficiently.

  FIG. 4 is a functional block diagram illustrating the configuration of the verification processing apparatus according to the present embodiment. As shown in the figure, the collation processing apparatus 100 includes an input unit 110, an output unit 120, a storage unit 130, a pre-processing unit 140, and a post-processing unit 150.

  Among these, the input unit 110 is an input unit that inputs various types of information, and includes a keyboard, a mouse, a microphone, a data reading device, and the like, and inputs, for example, the above-described XML data, query, and the like. The output unit 120 is a unit that outputs various types of information (for example, data corresponding to a query), and includes a monitor (or a display, a touch panel) or the like.

  The storage unit 130 is a storage unit (storage unit) that stores data and programs necessary for various processes performed by the pre-processing unit 140 and the post-processing unit 150. The XML data 131 is particularly closely related to the present invention. A path trie 132, a BIN file 133, query data 134, a sibling correspondence table 135, automaton data 136, a hit table 137, and a stack 138.

  The XML data 131 is document data having a hierarchical structure using element identifiers “<” and “/>” that are referred to as tags. FIG. 5 is a diagram illustrating an example of the data structure of XML data. If the XML data shown in FIG. 5 is represented by a tree representation, it can be shown as in FIG. FIG. 6 is a diagram when the XML data shown in FIG. 5 is represented in a tree representation. 6 is the same as the description of the tree representation of FIG.

  The path trie 132 is data in which overlapping paths of XML data are omitted and a unique ID is assigned to each element of the XML data. FIG. 7 is a diagram illustrating an example of the data structure of the path trie 132. As shown in the figure, this path trie 132 includes a plurality of tags (papers, paper, author, title), and a unique ID is assigned to each tag.

  In the example illustrated in FIG. 7, tag ID (1) is assigned to tag “papers”, tag ID (2) is assigned to tag “paper”, tag ID (3) is assigned to tag “author”, and tag “title” is assigned. Is assigned a tag ID (4).

  In the XML data (tree representation) shown in FIG. 6, the axis from paper to author and the axis from paper to title overlap, so the path trie 132 combines the overlapping axes into one axis. .

  FIG. 8 shows an example of the data structure of each tag shown in FIG. As shown in the figure, this tag includes a tag name, a tag ID, and a pointer to a child clause. Here, the “papers” tag shown in FIG. 7 will be described as an example. “Papers” is registered as the tag name, tag ID (1) is registered as the tag ID, and In the pointer, a pointer of “paper” as a child clause is registered.

  The BIN file 133 is data obtained by replacing each element included in the XML data 131 (see FIG. 5) with the ID of each tag of the path trie 132 (see FIG. 7). FIG. 9 is a diagram illustrating an example of the data structure of the BIN file 133. As shown in the figure, the BIN file 133 is composed of identification numbers 1001 to 1010 for identifying the position of each element and elements replaced with tag IDs.

  Specifically, comparing FIG. 5 and FIG. 9, <papers> is converted to [(1), <paper> is converted to [(2), and <author> is converted to [(3). After conversion, <title> is converted into [(4). Also, </ papers> is converted to / (1), </ paper> is converted to / (2), </ author> is converted to / (3), and </ title> / (4).

  The query data 134 is data that stores a query input from the input unit 110. FIG. 10 is a diagram illustrating an example of a query stored as the query data 134. The meaning of the query shown in FIG. 10 is the same as that of the query described in FIG.

  The sibling correspondence table 135 is a table for storing the sibling relationship of each element after axis conversion when axis conversion is performed on the query. FIG. 11 is a diagram illustrating an example of a data structure of the brother correspondence table 135. As shown in the figure, the sibling table 135 shows the sibling relationship of each element. For example, in FIG. 11, since “2 <3” is recorded, among the elements identified by the numbers 2 and 3, the element of the number 2 becomes an older brother and the element of the number 3 becomes an older brother. Represents.

  The automaton data 136 is data for storing an automaton generated based on the axis-converted query. Detailed description regarding the automaton data 136 will be described later.

  The hit table 137 is a table used when searching for a search object using the BIN file 133 and the automaton data 136. FIG. 12 is a diagram illustrating an example of the data structure of the hit table 137. As shown in the figure, the hit table 137 has a plurality of fields for storing the position of the BIN file 133 where the context node detection event C occurs and the position of the BIN file 133 where the predicate acceptance event (Am) is derived. Note that a description of the context node detection event and the predicate acceptance event will be described later.

  The stack 138 is data that temporarily stores data to be stored in the hit table 137. FIG. 13 is a diagram illustrating an example of a data structure of a stack. As shown in the figure, the stack 138 has one field for storing the position of the BIN file 133 where the context node detection event C occurs and the position of the BIN file 133 where the predicate acceptance event (Am) is derived.

  Returning to the description of FIG. 4, the pre-processing unit 140 is a unit that generates a path trie 132 and a BIN file 133 based on the XML data 131, and includes a path trie creation unit 141 and a BIN file creation unit 142. When the preprocessing unit 140 acquires XML data from the input unit 110, the preprocessing unit 140 stores the acquired XML data in the storage unit 130.

  The path trie creation unit 141 is a unit that creates a path trie 132 (see FIG. 7) based on the XML data 131 (see FIG. 5). Specifically, the path trie creation unit 141 analyzes the XML data 131 and detects a path in which the XML data 131 overlaps. If there are overlapping paths in the XML data 131, a tag corresponding to each element of the XML data 131 is created with one path remaining among the overlapping paths, and the parent and child of the XML data 131 are created. In accordance with the relationship, a path trie 132 (see FIG. 7) in which each tag is connected is created. The path trie creation unit 141 assigns a unique tag ID to each tag.

  The BIN file creation unit 142 is a means for creating a BIN file 133 (see FIG. 9) based on the XML data 131 (see FIG. 5) and the path trie 132 (see FIG. 7). Specifically, the BIN file creation unit 133 compares each element of the XML data 131 with the tag name of the path trie 132, assigns a tag ID of a tag name corresponding to the name of each element of the XML data 131, and outputs a BIN file. 133 is created.

  The post-processing unit 150 is a unit that performs collation processing and detects data corresponding to the query data 134, and includes an axis conversion processing unit 151, an automaton creation unit 152, and a collation processing unit 153. When the query data is acquired from the input unit 110, the post-processing unit 150 stores the query data as the query data 134 in the storage unit 130. In addition, the post-processing unit 150 outputs the detected data to the output unit 120.

  The axis conversion processing unit 151 is a unit that performs axis conversion on the query data 134. FIG. 14 is a diagram for explaining the outline of the processing of the axis conversion processing unit 151. As shown in the figure, the axis conversion processing unit 151 performs axis conversion on a query (including a retrograde axis), and generates a query including only child axes. Then, each element name of the query is compared with the tag name of the path trie 132, and each element is converted with the tag ID of the tag name corresponding to each element name.

  Below, the process of the axis conversion process part 151 is demonstrated concretely. In the axis conversion, the axis conversion processing unit 151 executes the parent axis conversion process after executing the sibling axis conversion process on the query data 134. Here, sibling axis conversion performed by the axis conversion processing unit 151 will be described first.

(Brother axis conversion processing)
In the sibling axis conversion process, the axis conversion processing unit 151 detects a sibling axis from the query data 134. For example, sibling axes are indicated by “following-sibling” and “preceding-sibling” on the query. When detecting the sibling axis, the axis conversion processing unit 151 converts the sibling axis into the parent axis and the child axis using the sibling axis conversion rule, and registers the sibling relationship in the sibling correspondence table 135.

Sibling axis conversion rules are
“/A/following-sibling::b⇒/a/../b”
"/A/preceding-sibling::b⇒/a/../b"
It becomes.

  FIG. 15 is a diagram for supplementarily explaining the sibling axis conversion process. In the drawing, the query for searching the node “C” of the XML data is “/ a / b / following-sibling :: c”, and it is understood that the sibling axis “following-sibling” is included. By applying the sibling axis conversion rule described above to this query “/ a / b / following-sibling :: c”, it is possible to convert it to “/a/b/../c”. It is possible to represent only with the child axis.

  In addition, the axis conversion processing unit 151 registers the sibling relationship in the sibling correspondence table 135 when the sibling axis is converted into the parent axis and the child axis. In the example shown in FIG. 15, b identified by No. 2 is an older brother, and c identified by No. 3 is a younger brother, so the information registered in the brother correspondence table 135 is “2 <3”.

  The axis conversion processing unit 151 converts the sibling axis into a parent axis and a child axis, and then applies an equivalence rule to the converted query, and nests the predicate part ([] part of the query) If there is a [] in it, it is called a nest. In the continuous predicate parts, the equivalence rule is applied to rearrange the queries so that the predicate part including the parent axis comes first. For example, the equivalence rule is applied to “π [a] [../ b] [c / d]” and rearranged to “π [../ b] [a] [c / d]”.

Equivalence rules 1 to 7 exist as follows. Note that π1 and π2 below are path expressions of arbitrary queries. Further, when S [π1] (x) = S [π2] (x) holds for an arbitrary child node x∈N, π1 and π2 are said to be the same value and are expressed as “π1≡π2”.
Equivalence rule 1: π1 / π≡π2 / π (applicable only when π1≡π2)
Equivalence rule 2: π / π1≡π / π2 (applicable only when π1≡π2)
Equivalence rule 3: π [π1] ≡π [π2] (applicable only when π1≡π2)
Equivalence rule 4: π1 [π] ≡π2 [π] (applicable only when π1≡π2)
Equivalence rule 5: π [π1 [π2]] ≡π [π1 / π2]
Equivalence rule 6: π [[π1] π2] ≡π [π1] [π2]
Equivalence rule 7: π [π1] [π2] ≡π [π2] [π1]

(Parent axis conversion process)
In the parent axis conversion process, the axis conversion processing unit 151 detects the query data parent axis. Then, the axis conversion processing unit 151 applies a parent axis conversion rule and converts the detected parent axis into a child axis.
For example, the method disclosed in Reference Document 1 (D. Olteanu et al., “XPath: Looking Forward”, Proc. XMLDM'02, 2002.) is used as a method for converting a parent axis into a child axis. Can do.
The parent axis conversion rule is
Parent axis conversion rule 1: π / a /../ ≡π [a]
Parent axis conversion rule 2: a /../ ≡ ./ [π] / a
Exists.

  After converting the parent axis to the child axis, the axis conversion processing unit 151 applies the equivalence rule to the converted query and deletes the predicate part from nesting. In the continuous predicate parts, the equivalence rule is applied to rearrange the queries so that the predicate part including the parent axis comes first. Note that the equivalence rule is the same as the above equivalence rules 1 to 7, and thus the description thereof is omitted.

Here, a specific example of processing for converting a path of a query including the parent axis by applying the parent axis conversion rule and the equivalence rule will be described. The path of the query to be converted is π = /b1/b2[b3/b4/../../../b8]
And This path π includes three parent axes “../” to be converted.

The When [pi ₁ obtained by applying the parent axis conversion rule 1 for the leftmost parent axis of the [pi,
π ₁ = / b1 / b2 [b3 [b4] ../../ b8]
It becomes. And, if the parent axis change rule 1 applied to the leftmost parent axis of π ₁ is π ₂ ,
π ₂ = / b1 / b2 [b3 [b4]] ../ b8]
It becomes.

Subsequently, applying equivalence rule 5 to π ₂ gives
π ₂ = / b1 / b2 [b3 / b4] ../ b8]
When the equivalence rule 6 is applied to π ₂ to which the equivalence rule 5 is applied,
π ₂ = / b1 / b2 [b3 / b4] [../ b8]
It becomes.

When the equivalence rule 7 is applied to π ₂ to which the equivalence rule 6 is applied,
π ₂ = / b1 / b2 [../ b8] [b3 / b4]
It becomes. Then, when π ₃ is the π ₂ to which the equivalence rules 5 to 7 are applied, and the parent axis conversion rule 2 is π ₃ ,
π ₂ = / b1 [b8] b2 [b3 / b4]
It becomes.

In addition, when performing the parent axis (or ancestor axis) conversion processing on the query, the axis conversion processing unit 151 performs parent axis conversion after expanding the descendant axes with a path trie. For example,
π = /a//../d
When executing the parent axis conversion process for
π = /a/b/../d, a / b / c / d /../ d
After expanding to the parent axis conversion process,
π = / a [b] d, a / b / c [b] d
Convert to

  The axis conversion processing unit 151 performs a sibling axis conversion process and a parent axis conversion process on the query stored in the query data 134, and registers the query subjected to the axis conversion in the query data 134 (before the axis conversion). Update the query with the post-axis conversion query). Then, the axis conversion processing unit 151 compares each element name of the converted query and the tag name of the path trie 132, and converts each element name of the query into a tag ID. A query converted to a tag ID is referred to as a conversion query.

  Returning to the description of FIG. 4, the automaton creating unit 152 is a unit that creates automaton data corresponding to the transformation query created by the axis transformation processing unit 151. The automaton data created by the automaton creation unit 152 is stored in the storage unit 130 as automaton data 136.

Here, the processing of the automaton creation unit 152 will be specifically described. FIG. 16 is a diagram for supplementarily explaining the processing of the automaton creation unit 152. Here, for convenience of explanation, the query is
Q = / Syain / ACT / [contains (cast, "Asai")] chara [contains (name, "Blue")]
And a conversion query that converts each element of the query into a tag ID
Q '= (2) [(5): e1] (3) [(6): e2]
Let us explain the automaton generation. In this conversion query Q ′, “(2)” corresponds to “/ Syain / ACT”, “(3)” corresponds to “chara”, and “[(5): e1]” corresponds to [contains (cast, "Asai")], and "[(6): e2]" corresponds to "[contains (name," blue ")]" (automaton corresponding to conversion query Q ' Is the automaton shown in the lower part of FIG. 16).

  The automaton illustrated in FIG. 16 includes a plurality of node structures 20 to 27 and event structures 30 to 34. In addition, when a line connecting the node structures 20 to 26 and the event structures 30 to 31 satisfies a condition corresponding to the line, the process moves in the direction of the arrow. Note that ε in FIG. 16 indicates that the process shifts in the direction of the arrow unconditionally, and Σ \ {n} indicates that the process shifts in the direction of the arrow in cases other than n.

First, the automaton creation unit 152 analyzes the conversion query Q ′, and
Set of predicate path IDs: A = {a1, ... an} (n is a natural number)
Set of branch path IDs: A = {z1, ... zn} (n is a natural number)
Context path ID: c
Evaluation path ID: d
Keyword set key (ai) for each ai∈A
To extract.

  In the conversion query Q ′ illustrated in FIG. 16, the automaton creation unit 152 extracts “(5), (6)” as a set of predicate path IDs, and “(2), (3 ) ”Is extracted. Also, “(3)” is extracted as the context path ID. As a method for extracting the context path ID, a corresponding one is extracted before the last predicate part [] of the conversion query Q ′.

  In addition, the automaton creation unit 152 extracts “(2)” as the evaluation path ID. As the evaluation path ID, for example, the leftmost one of the conversion query Q ′ is extracted. Then, “e1 (Asai)” and “e2 (blue)” are extracted as the keyword set key (ai).

  Subsequently, the automaton creating unit 152 reads the initial state Ini (node structure 20 in FIG. 16), the start state Open (start symbol “[”) of the automaton; the node structure 21), and the end state Close (end). The symbol “/”; node structure 27) is created. Note that Goto (Ini, “[”) = Open and Goto (Ini, “/”) = Close.

  The automaton creation unit 152 performs the following processing 1-1 to 1-6 for any i = 1 to n. First, in process 1-1, the automaton creation unit 152 creates a state State (ai) corresponding to the predicate path ID (aiεA). In the example shown in FIG. 16, a node structure 22 of State (a1) corresponding to (5) and a node structure 24 of State (a2) corresponding to (6) are generated.

  In process 1-2, the automaton creation unit 152 creates a keyword reference automaton that accepts key (ai) and connects it from the node structure of each state State (ai). In the example shown in FIG. 16, the node structures 22 and 23 from the node structure 22 of State (a1) to the event structure 30 “A1” are connected to the event structure 30, and the node of State (a2) The node structures 24, 25 and 26 from the structure 24 to the event structure 31 “A2” and the event structure 31 are connected.

  Subsequently, in process 1-3, the automaton creation unit 152 sets the node structure 22 of State (a1) so that Goto (Open, ai) = State (ai) for each state State (ai). And the node structure 21 are connected, and the node structure 24 and the node structure 21 of State (a2) are connected.

  Also, in process 1-4, the automaton creating unit 152 sets the node structure of State (a2) so that Goto (Close, b) = State (ai) for any child of ai on the path try. 24 and the node structure 27 are connected. In the example shown in FIG. 16, the child of the tag (name) corresponding to the tag ID (6) becomes the tag (ID) corresponding to the tag ID (7).

  In process 1-5, the automaton creation unit 152 creates a state State (zi) corresponding to the branch path ID (ziε). In the example shown in FIG. 16, an event structure 32 “Z1” of State (z1) corresponding to (2) and an event structure 33 “Z2” of State (z2) corresponding to (3) are generated. .

  In process 1-6, the automaton creation unit 152 sets the event structure 32 and the node structure of State (z1) so that Goto (close, zi) = State (zi) is satisfied for each state State (z1). The body 27 is connected, and the event structure 33 of State (z2) and the node structure 27 are connected.

  Subsequently, the automaton creation unit 152 creates a state State (c) for the context path ID “c”. In the example shown in FIG. 16, the event structure 34 “C” is created. Then, the node structure 21 and the event structure 34 are connected so that Goto (Open, c) = State (c).

  Further, the automaton creating unit 152 creates a state State (d) corresponding to the evaluation path ID “d”. In the example shown in FIG. 16, an event structure 32 “D” is created (in FIG. 16, “Z1” and “D” are combined into one event structure 32). Then, the node structure 33 and the event structure 27 are connected so that Goto (close, d) = State (d).

  The automaton creation unit 152 executes various processes as described above, creates automaton data corresponding to the conversion query Q ′, and stores the created automaton data in the storage unit 130.

  Here, the data structure of the node structure and the data structure of the event structure included in the above-described automaton data will be described. FIG. 17 is a diagram illustrating an example of the data structure of the node structure, and FIG. 18 is a diagram illustrating an example of the data structure of the event structure.

  As shown in FIG. 17, the node structure includes a node ID for identifying the node structure, a pointer to the event structure, and a pointer to another node structure. For example, taking the node structure 21 shown in FIG. 16 as an example, a pointer corresponding to the event structure 34 is stored as a pointer to the event structure. In addition, pointers corresponding to the nodes 20, 22, and 24 are stored as pointers to the node structure.

  As shown in FIG. 18, the event structure includes an event ID for identifying the event structure, a query ID for identifying the query, and an event type (context node detection event, predicate acceptance event, predicate evaluation event, query evaluation). Event type for identifying the event), the data position of the event structure, and pointers to other event structures.

  Returning to the explanation of FIG. 4, the collation processing unit 153 is means for outputting data corresponding to the query data 134 based on the BIN file 133 and the automaton data 136. Here, the process of the collation process part 153 is demonstrated concretely. For convenience of explanation, the BIN file shown in FIG. 19 and the automaton data shown in FIG. 16 are used for explanation. FIG. 19 is a diagram illustrating an example of the data structure of a BIN file for explaining the collation processing.

  An event E that occurs in the process in which the verification processing unit 153 performs processing by substituting the BIN file for automaton data is defined as E = (Q, T, P). Here, “Q” included in the event E indicates a query ID, “T” indicates an event type, and “P” indicates a data position at the moment when the event occurs.

  When “T” of event E is the context node detection event (C), the matching processing unit 153 registers a new entry in the hit table 137 (see FIG. 12) with the query ID “Q”, and the contents of the registered new entry The contents of the current stack 138 (see FIG. 13) are registered.

  When “T” of event E is a predicate acceptance event (Am), the matching processing unit 153 registers “P” included in the event E in the hit table 137 of the query ID “Q” and the mth item of the stack 138. To do.

  When “T” of event E is a predicate evaluation event (Zm), the matching processing unit 153 deletes the entry in which the mth column is blank in the hit table 137 of the query ID “Q”, and the stack 138 Delete the mth item.

  When “T” of event E is a query evaluation event (D), the collation processing unit 153 outputs the entry remaining in the hit table with the query ID “Q” to the output unit 120 as a correct answer.

  Based on the above, the processing of the collation processing unit 153 using the automaton shown in FIG. 16 and the BIN file shown in FIG. 19 will be described separately for the positions “1001” to “1011” of the BIN file.

(BIN file position “1001”)
The matching processing unit 153 substitutes the data “[((1) Sigma Squadron Nakahara Jar)” corresponding to the position “1001” of the BIN file for the automaton. Then, such data starts from the node structure 20 and when it moves to the node structure 21, the next corresponding character does not exist, so the data returns to the node structure 20 and the search for the position “1001” is completed. To do.

(BIN file position “1002”)
The verification processing unit 153 substitutes the data “[(2)” corresponding to the position “1002” of the BIN file for the automaton. Then, such data starts from the node structure 20 and when it moves to the node structure 21, the next corresponding character does not exist, so the data returns to the node structure 20 and the search for the position “1002” is completed. To do.

(BIN file position “1003”)
The matching processing unit 153 substitutes the data “[(3) Sigma Blue 1” corresponding to the position “1003” of the BIN file for the automaton. Then, such data reaches the event structure 34 starting from the node structure 20. When the event structure 34 is reached, the verification processing unit 153 generates an event E1 = (Q1, C, 1003).

  FIG. 20 is a diagram illustrating the state of the hit table 137 when the event E1 = (Q1, C, 1003) occurs. Note that the values of the stack 138 are copied to A1 to Am corresponding to the row “1003” of the hit table 137 shown in FIG. 20 (since nothing is registered in the stack 138 at this stage, Nothing is copied to the hit table 137 at this stage).

(BIN file position “1004”)
The matching processing unit 153 substitutes the data “[(6) Blue / (6)” corresponding to the position “1004” of the BIN file for the automaton. Then, the data reaches the event structure 31 with the node structure 20 as a starting point. When the event structure 31 is reached, the verification processing unit 153 generates an event E2 = (Q1, A2, 1004).

  FIG. 21 is a diagram showing the state of the hit table 137 when the event E2 = (Q1, A2, 1004) occurs. FIG. 22 shows the state when the event E2 = (Q2, A2, 1004) occurs. It is a figure which shows the state of the stack 138 of. As shown in FIGS. 21 and 22, “1004” is registered at the corresponding position of “A2”.

(BIN file location “1005”)
The matching processing unit 153 substitutes data “/ (3)” corresponding to the position “1005” of the BIN file for the automaton. Then, such data reaches the event structure 32 starting from the node structure 20. When the event structure 32 is reached, the matching processing unit 153 generates an event E3 = (Q1, Z2, 1005).

  When the event E3 = (Q1, Z2, 1005) occurs, the collation processing unit 153 refers to the hit table 137 and deletes a line in which “A2” is not set. As shown in FIG. 21, since a value is set in “A2” in the hit table 137 at this stage, no line deletion is executed. When event E3 = (Q1, Z2, 1005) occurs, the collation processing unit 153 clears “A2” in the stack 138.

(BIN file location “1006”)
The matching processing unit 153 substitutes data “[(3) Sigma Blue 2” corresponding to the position “1006” of the BIN file for the automaton. Then, such data reaches the event structure 34 starting from the node structure 20. When the event structure 34 is reached, the matching processing unit 153 generates an event E4 = (Q1, C, 1006).

  FIG. 23 is a diagram showing the state of the hit table 137 when the event E4 = (Q1, C, 1006) occurs. As shown in the figure, “1006” is registered in the “C” column of the hit table 137.

(BIN file location “1007”)
The matching processing unit 153 substitutes the data “[(6) Blue / (6)” corresponding to the position “1007” of the BIN file for the automaton. Then, the data reaches the event structure 31 with the node structure 20 as a starting point. When the event structure 31 is reached, the verification processing unit 153 generates an event E5 = (Q1, A2, 1007).

  FIG. 24 is a diagram showing the state of the hit table 137 when the event E5 = (Q1, A2, 1007) occurs, and FIG. 25 shows the state when the event E5 = (Q1, A2, 1007) occurs. It is a figure which shows the state of the stack 138 of. As shown in FIGS. 24 and 25, “1007” is registered at the corresponding position of “A2”.

(BIN file location “1008”)
The collation processing unit 153 substitutes the data “/ (3)” for the position “1008” of the BIN file for the automaton. Then, such data reaches the event structure 33 with the node structure 20 as a starting point. When the event structure 33 is reached, the verification processing unit 153 generates an event E6 = (Q1, Z2, 1008).

  When the event E6 = (Q1, Z2, 1008) occurs, the collation processing unit 153 refers to the hit table 137 and deletes a line in which “A2” is not set. As shown in FIG. 24, since a value is set in “A2” in the hit table 137 at this stage, no line deletion is executed. When event E6 = (Q1, Z2, 1008) occurs, the collation processing unit 153 clears “A2” in the stack 138.

(BIN file position “1009”)
The matching processing unit 153 substitutes the data “[(5) Tatsuya Asai / (5)” for the position “1009” of the BIN file into the automaton. Then, such data reaches the event structure 30 starting from the node structure 20. When the event structure 30 is reached, the matching processing unit 153 generates an event E7 = (Q1, A1, 1009).

  FIG. 26 is a diagram showing the state of the hit table 137 when the event E7 = (Q1, A1, 1009) occurs, and FIG. 27 shows the state when the event E7 = (Q1, A1, 1009) occurs. It is a figure which shows the state of the stack 138 of. As shown in FIGS. 26 and 27, the corresponding position “1009” of “A1” is registered.

(BIN file position “1010”)
The matching processing unit 153 substitutes the data “/ (2)” for the position “1010” of the BIN file into the automaton. Then, such data reaches the event structure 32 starting from the node structure 20. When the event structure 32 is reached, the matching processing unit 153 generates events E8 = (Q1, Z1, 1010), E9 = (Q1, D, 1010).

  When the event E8 = (Q1, Z1, 1010) occurs, the collation processing unit 153 refers to the hit table 137 and deletes a line in which “A1” is not set. As shown in FIG. 26, since a value is set in “A1” in the hit table 137 at this stage, no line deletion is executed. When event E8 = (Q1, Z1, 1010) occurs, the collation processing unit 153 clears “A1” in the stack 138.

  When the event E9 = (Q1, D, 1010) occurs, the matching processing unit 153 refers to the hit table 137 and outputs the position information registered in the “C” column of the hit table 137 to the output unit 120. In the example shown in FIG. 26, the positions “1003” and “1006” of the BIN file are output. Such position data is data corresponding to the query data 134. When event E9 = (Q1, D, 1010) occurs, collation processing unit 153 deletes data registered in hit table 137.

(BIN file position “1011”)
The matching processing unit 153 substitutes data “/ (1)” corresponding to the position “1011” of the BIN file for the automaton. Then, such data starts from the node structure 20 and when it moves to the node structure 27, there is no next corresponding character. Therefore, the data returns to the node structure 20 and the search for the position “1011” is completed. To do.

  Next, the process of the collation processing apparatus 100 according to the present embodiment will be described. FIG. 28 is a flowchart illustrating the processing procedure of the verification processing apparatus 100 according to the present embodiment. As shown in the figure, the collation processing apparatus 100 acquires XML data 131 (step S101), the path trie creation unit 141 creates a path trie 132 based on the XML data 131 (step S102), and a BIN file creation unit. 142 creates a BIN file based on the XML data 131 and the path trie 132 (step S103).

  And the collation processing apparatus 100 acquires the query data 134 (step S104), and determines whether a retrograde axis exists in the query data 134 (or whether axis conversion is necessary) (step S105).

  If there is no retrograde axis in the query data 134 (or if no axis conversion is required) (No in step S106), the process proceeds to step S108. The description regarding step S108 will be described later.

  On the other hand, when the retrograde axis exists in the query data 134 (or when axis conversion is necessary) (Yes in step S106), the axis conversion processing unit 151 executes the axis conversion process of the query data 134 (step S107). ), Each element of the query data 134 is converted into a tag ID (path ID) (step S108).

  Then, in the collation processing device 100, the automaton creation unit 152 creates automaton data 136 based on the query data 134 (step S109), and the collation processing unit 153 performs collation processing based on the automaton data 136 and the BIN file 133. Execute (Step S110).

  Next, the axis conversion process shown in step S107 of FIG. 28 will be described. FIG. 29 is a flowchart illustrating the axis conversion process according to the present embodiment. As shown in the figure, the axis conversion processing unit 151 sets π as the path expression of the query data, initializes the sibling correspondence table 135 (step S201), and determines whether or not a sibling axis exists in π ( Step S202).

  If no sibling axis exists in π (step S203, No), the process proceeds to step S208. The description regarding step S208 will be described later. On the other hand, if there is a sibling axis in π (step S203, Yes), the sibling axis conversion rule is applied to the leftmost sibling axis of π (step S204), and the sibling relationship is registered in the sibling correspondence table 135. (Step S205).

  When the equivalence rule can be applied, the axis conversion processing unit 151 applies the equivalence rule to π (step S206) and updates the path expression π of the query data 134 (step S207).

  Subsequently, the axis conversion processing unit 151 determines whether or not a parent axis exists in π (step S208). If no parent axis exists in π (step S209, No), the process proceeds to step S213. . The description regarding step S213 will be described later.

  On the other hand, when the parent axis exists in π (step S209, Yes), the parent axis conversion rule is applied to the leftmost parent axis of π (step S210), and the equivalence rule can be applied. The equivalence rule is applied to π (step S211), the path expression π of the query data 134 is updated (step S212), and the path expression π of the query data 134 and the sibling correspondence table 135 are output (step S213).

  Next, the automaton creation process shown in step S109 of FIG. 28 will be described. FIG. 30 is a flowchart illustrating the automaton creation process according to the present embodiment. As shown in the figure, the automaton creation unit 152 analyzes the query data 134 and extracts a set of predicate path IDs, a set of branch path IDs, a context path ID, and a keyword set (step S301).

  Then, the automaton creating unit 152 creates an initial state Ini, a start state Open, and an end state Close of the automaton (Step S302), creates a state State (ai) corresponding to the predicate path ID (Step S303), and sets a keyword set. Is created and connected to State (ai) (step S304).

  Subsequently, the automaton creating unit 152 sets Goto (Opne, ai) = State (ai) (step S305), and Goto (Close, d) = State ( ai) (step S306), a state State (zi) for the branch path ID is created (step S307), and Goto (Opne, zi) = State (zi) is set (step S308).

  Then, the automaton creation unit 152 creates a state State (c) for the context path ID (step S309), sets Goto (Open, c) = State (c) (step S310), and corresponds to the evaluation path ID. A state State (d) is created (step S311), and Goto (Open, d) = State (d) is set (step S312).

  Next, the collation process shown in step S110 of FIG. 28 will be described. FIG. 31 is a flowchart illustrating the collating process according to the present embodiment. As shown in the figure, the collation processing unit 153 sets s = Ini (initial state) (step S401), determines whether or not the next character a exists in the BIN file 133 (step S402), and If it does not exist (step S403, No), the collation process is terminated.

  On the other hand, when the next character a is present in the BIN file 133 (step S403, Yes), s = Goto (s, a) is set (step S404), and it is determined whether or not s is an event occurrence node (step S405). ).

  Then, when s is not an event occurrence node (No at Step S406), the verification processing unit 153 proceeds to Step S402. On the other hand, when s is an event occurrence node (step S406, Yes), an event evaluation process is executed (step S407), and the process proceeds to step S402.

  Next, the event evaluation process shown in step S407 of FIG. 31 will be described. FIG. 32 is a flowchart illustrating event evaluation processing according to the present embodiment. As shown in the figure, the collation processing unit 153 sets the generated event to E = (Q, T, P), sets the Q hit table 137 to H (Q) (step S501), and sets the stack 138 to Stack. = Φ is initialized (step S502).

  Then, the matching processing unit 153 determines whether or not T is a context detection event (step S503). If T is a context detection event (step S504, Yes), a new entry (P , Stack) is added (step S505), and the event evaluation process is terminated.

  On the other hand, when T is not a context detection event (step S504, No), it is determined whether T is a predicate acceptance event (Am) (step S506), and when T is a predicate acceptance event (Am). (Step S507, Yes), P is entered in the m-th item of the hit table H (Q), P is entered in the m-th item of the stack (step S508), and the event evaluation process is terminated.

  On the other hand, if T is not a predicate acceptance event (Am) (step S507, No), it is determined whether T is a predicate acceptance event (Zm) (step S509), and if T is a predicate acceptance event (Zm). (Yes in step S510), deletes all entries in the hit table H (Q) whose mth item is blank, deletes the mth item in the stack 138 (step S511), and performs event evaluation processing. finish.

  On the other hand, if T is not a predicate acceptance event (Zm) (step S510, No), T is determined as a query evaluation event (step S512), and all entries in the hit table H (Q) are output as solutions (step S512). S513), the hit table H (Q) is cleared (step S514).

  As described above, in the collation processing apparatus 100 according to the present embodiment, the path trie creation unit 141 creates the path trie 132 based on the XML data 131, and the BIN file creation unit 142 creates the BIN based on the XML data 131 and the path trie 132. A file 133 is created. Then, the axis conversion processing unit 151 performs the axis conversion processing of the query data 134 based on the axis conversion algorithm, and the automaton creation unit 152 creates the automaton data 136 based on the axis-converted query data 134, and the matching processing unit Since 153 inputs the BIN file 133 to the automaton data 136 and outputs data corresponding to the query data 134, even if the reverse axis of the query data is included, it corresponds to the query data from the XML data 131 by the stream processing. Data can be searched.

  Further, in the collation processing apparatus 100 according to the present embodiment, the BIN file creation unit 142 creates the BIN file 133 in which each element of the XML data 131 is converted into the tag ID, and the collation processing unit 153 is converted into the tag ID. Since the collation process only for the numerical comparison is performed using the BIN file 133, the burden on the collation processing apparatus 100 can be reduced.

  Further, in the collation processing device 100 according to the present embodiment, the axis conversion processing unit 151 sets all the axes of the query data 134 as children based on the axis conversion algorithm (sibling axis conversion rule, parent axis conversion rule, equivalence rule). Since it is converted into an axis, the hierarchical management of the query data 134 is not required, and data corresponding to the query data 134 can be searched at high speed.

  By the way, among the processes described in the present embodiment, all or a part of the processes described as being automatically performed can be manually performed, or the processes described as being performed manually can be performed. All or a part can be automatically performed by a known method. In addition, the processing procedure, control procedure, specific name, and information including various data and parameters shown in the above-described document and drawings can be arbitrarily changed unless otherwise specified.

  Further, the configuration of the collation processing device 100 shown in FIG. 4 is functionally conceptual, and does not necessarily need to be physically configured as illustrated. In other words, the specific form of distribution / integration of each device is not limited to that shown in the figure, and all or a part thereof may be functionally or physically distributed or arbitrarily distributed in arbitrary units according to various loads or usage conditions. Can be integrated and configured. Furthermore, each processing function performed in each device is realized by a CPU (or MCU, MPU) and a program that is analyzed and executed by the CPU, or hardware by wired logic. It can be realized as wear.

  FIG. 33 is a diagram illustrating a hardware configuration of a computer included in the collation processing device 100 illustrated in FIG. 4. The computer 60 includes an input device 61 that accepts data input from a user, a monitor 62, a RAM (Random Access Memory) 63, a ROM (Read Only Memory) 64, a medium reader 65 that reads data from a storage medium, and a CPU (Central A processing unit (66) and an HDD (Hard Disk Drive) 67 are connected by a bus 68.

  The HDD 67 stores a pre-processing program 67b and a post-processing program 67c that exhibit functions similar to the functions of the verification processing device 100 described above. Then, the CPU 66 reads the pre-processing program 67b and the post-processing program 67c from the HDD 67 and executes them, thereby starting the pre-processing process 66a and the post-processing process 66b that realize the functions of the functional units of the collation processing device 100 described above. . The pre-processing process 66a and the post-processing process 66b correspond to the pre-processing unit 140 and the post-processing unit 150 shown in FIG.

  In addition, the HDD 67 stores various data 67a corresponding to the data stored in the storage unit 130 of the collation processing device 100 described above. The various data 67a correspond to the XML data 131, the path trie 132, the BIN file 133, the query data 134, the sibling correspondence table 135, the automaton data 136, the hit table 137, and the stack 138 shown in FIG.

  The CPU 66 stores various data 67 a in the HDD 67, reads the various data 67 a from the HDD 67, stores it in the RAM 63, and performs a collation process using the various data 63 a stored in the RAM 63.

(Supplementary note 1) Document storage procedure for storing document data having a hierarchical structure in which elements are separated by element identifiers in a storage device in a computer;
When a search expression for searching for data included in document data stored in the storage device is acquired, axis conversion is performed on the acquired search expression, and the search expression is converted into a search expression configured by child axes. Axis conversion procedure to convert,
An automaton creation procedure for identifying an element identifier type included in the search expression converted by the axis conversion procedure and creating an automaton corresponding to the search expression;
A collation processing procedure for collating data contained in the document data and the automaton in order and outputting data corresponding to the search formula;
Verification processing program for executing

(Supplementary Note 2) The axis conversion procedure determines whether or not a sibling axis exists in the search expression, and if a sibling axis exists, converts the sibling axis into a parent axis and a child axis. The collation processing program according to appendix 1, characterized in that.

(Supplementary Note 3) The collation processing procedure sequentially stores data detected in the process of collating the data included in the document data with the automaton in the temporary storage table, and the temporary data is stored when the collation is completed. The collation processing program according to appendix 1 or 2, wherein the data stored in the storage table is output.

(Supplementary note 4) Any one of Supplementary notes 1 to 3, further causing a computer to execute a numerical value conversion procedure for converting each element identifier included in the document data and the search formula stored in the storage device into a numerical value. The verification processing program described in 1.

(Supplementary Note 5) Document storage step of storing document data having a hierarchical structure in which elements are divided by element identifiers in a storage device;
When a search expression for searching for data included in document data stored in the storage device is acquired, axis conversion is performed on the acquired search expression, and the search expression is converted into a search expression configured by child axes. An axis conversion process to convert;
An automaton creating step of identifying an element identifier type included in the search formula converted by the axis conversion step and creating an automaton corresponding to the search formula;
A collation processing step of sequentially collating data included in the document data and the automaton and outputting data corresponding to the search formula;
The collation processing method characterized by including.

(Supplementary Note 6) Document storage means for storing document data having a hierarchical structure in which elements are divided by element identifiers;
When a search expression for searching for data included in document data stored in the document storage means is acquired, axis conversion is performed on the acquired search expression, and the search expression is configured by a child axis. Axis conversion means for converting to
Automaton creating means for identifying the type of element identifier included in the search expression converted by the axis conversion means and creating an automaton corresponding to the search expression;
Collating processing means for sequentially collating data included in the document data and the automaton and outputting data corresponding to the search formula;
A collation processing device comprising:

  As described above, the collation processing program and the collation processing device according to the present invention are useful for a retrieval system that retrieves data corresponding to a retrieval formula from document data having a hierarchical structure in which elements are separated by element identifiers, In particular, it is suitable when it is necessary to search data corresponding to the search formula at a high speed regardless of the configuration of the search formula.

It is a figure which shows the tree representation of XML data, and the stream representation of XML data. It is a figure which shows an example of the query containing a retrograde axis. It is a figure which shows the search result at the time of searching the XML data of FIG. 1 by the query as shown in FIG. It is a functional block diagram which shows the structure of the collation processing apparatus concerning a present Example. It is a figure which shows an example of the data structure of XML data. It is a figure at the time of expressing the XML data shown in FIG. 5 by a tree expression. It is a figure which shows an example of the data structure of a path trie. It is a figure which shows an example of the data structure of each tag shown in FIG. It is a figure which shows an example of the data structure of a BIN file. It is a figure which shows an example of the query memorize | stored as query data. It is a figure which shows an example of the data structure of a sibling correspondence table. It is a figure which shows an example of the data structure of a hit table. It is a figure which shows an example of the data structure of a stack. It is a figure for demonstrating the outline | summary of a process of an axis conversion process part. It is a figure for supplementary explanation of brother axis conversion processing. It is a figure for supplementary explanation of processing of an automaton creation part. It is a figure which shows an example of the data structure of a node structure. It is a figure which shows an example of the data structure of an event structure. It is a figure which shows an example of the data structure of the BIN file for demonstrating collation processing. It is a figure which shows the state of a hit table at the time of event E1 = (Q1, C, 1003) generating. It is a figure which shows the state of a hit table at the time of event E2 = (Q2, A2, 1004) generating. It is a figure which shows the state of a stack | stuck at the time of event E2 = (Q2, A2, 1004) generate | occur | produced. It is a figure which shows the state of a hit table at the time of event E4 = (Q1, C, 1006) generating. It is a figure which shows the state of a hit table at the time of event E5 = (Q1, A2, 1007) generating. It is a figure which shows the state of a stack | stuck when event E5 = (Q1, A2, 1007) generate | occur | produced. It is a figure which shows the state of a hit table at the time of event E7 = (Q1, A1, 1009) generating. It is a figure which shows the state of a stack | stuck when event E7 = (Q1, A1, 1009) generate | occur | produced. It is a flowchart which shows the process sequence of the collation processing apparatus concerning a present Example. It is a flowchart which shows the axis conversion process concerning a present Example. It is a flowchart which shows the automaton creation process concerning a present Example. It is a flowchart which shows the collation process concerning a present Example. It is a flowchart which shows the event evaluation process concerning a present Example. It is a figure which shows the hardware constitutions of the computer with which the collation processing apparatus shown in FIG. 4 is provided. It is a figure for demonstrating the problem of a prior art.

Explanation of symbols

60 Computer 61 Input Device 62 Monitor 63 RAM
63a, 67a Various data 64 ROM
65 Medium reader 66 CPU
66a Pre-processing process 66b Post-processing process 67 HDD
67b Pre-processing program 67c Post-processing program 68 Bus 100 Collation processing device 110 Input unit 120 Output unit 130 Storage unit 131 XML data 132 Past tri 133 BIN file 134 Query data 135 Sibling correspondence table 136 Automaton data 137 Hit table 138 Stack 140 Preprocessing unit 141 Path trie creation unit 142 BIN file creation unit 150 Post processing unit 151 Axis conversion processing unit 152 Automaton creation unit 153 Collation processing unit

Claims (4)

A document storage procedure for storing, in a storage device, document data having a hierarchical structure in which elements are separated by element identifiers in a computer;
A search expression for searching for data included in the document data stored in the storage device is acquired, and when a sibling axis exists in the search expression, axis conversion is performed on the search expression to perform axis conversion. If the search formula contains a parent axis , an axis conversion procedure for converting to a search formula composed only of child axes by further performing axis conversion on the search formula that has undergone axis conversion, ,
An automaton creation procedure for identifying an element identifier type included in the search expression converted by the axis conversion procedure and creating an automaton corresponding to the search expression;
A collation processing procedure for collating data contained in the document data and the automaton in order and outputting data corresponding to the search formula;
Verification processing program for executing The collation processing procedure sequentially stores data detected in the process of sequentially collating data included in the document data and the automaton in a temporary storage table, and stores the data in the temporary storage table when collation is completed. The collation processing program according to claim 1 , wherein the stored data is output. The collation processing program according to claim 1 or 2 , further causing a computer to execute a numerical value conversion procedure for converting each element identifier included in the document data and the search expression stored in the storage device into a numerical value. Document storage means for storing document data having a hierarchical structure in which elements are separated by element identifiers;
A search expression for searching for data included in the document data stored in the document storage means is acquired, and when there is a sibling axis in the search expression, axis conversion is performed on the search expression, and axis conversion is performed. Axis conversion means for converting into a search expression composed only of child axes by further performing axis conversion on the search expression that has undergone axis conversion when the search expression that has been performed includes a parent axis When,
Automaton creating means for identifying the type of element identifier included in the search expression converted by the axis conversion means and creating an automaton corresponding to the search expression;
Collating processing means for sequentially collating data included in the document data and the automaton and outputting data corresponding to the search formula;
A collation processing device comprising:

Images