JP2013246522A - Structured document retrieval device and program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To enable a structure retrieval by combining both of structure information by an XML (Extensible Markup Language) and structure information by annotation tags.SOLUTION: The structured document retrieval device according to the present invention includes: a processor for executing a program; a first storage area for storing the program; a second storage area for storing structured documents satisfying tree structure conditions and annotation data attached to the documents; a document structure list construction unit that allocates a text of a structured document to a structure in which root elements of DOM (Document Object Model) tree are made common, the structure being individually obtained from an inclusion relation of tags of the structured document and an inclusion relation of tags of the annotation data, and that generates a text common DOM tree; and a retrieval processing unit for retrieving an element matching a retrieval query from the text common DOM tree.

Description

  According to the present invention, a document described in a structured language (hereinafter referred to as “structured document”) and a structured document to which annotation data is assigned in an arbitrary format are based on the tag structure and / or character string data. In particular, the present invention relates to a structured document search apparatus for searching and a program for realizing the function thereof through a computer.

  XML (Extensible Markup Language) is a data format that makes it possible to describe structural information for text. By using character strings enclosed in "<" and ">" called tags, Enable description. XML can express a hierarchical tree structure by nesting tags, and can change the hierarchical tree structure by adding / deleting tags. For this reason, XML is widely used as a format for recording financial information, recording patent specifications, exchanging data in electronic commerce, and a software file format. Hereinafter, a document described using XML is referred to as an XML document. An XML document can be searched using both the structure and text as search conditions. The search query method of the XML document includes the XPath of W3C recommendation.

  On the other hand, UIMA (Unstructured Information Management Architecture) is one of techniques for giving annotations to general text data. UIMA is a technique used to manage data such as unstructured documents, and provides a platform that allows annotation tags to be attached to documents. Unlike XML, UIMA does not need to be tagged in a format that satisfies the tree structure condition. For this reason, UIMA does not need to satisfy the tree structure relationship between the structures, such as the analysis of the grammatical structure obtained by the computer and the marking on technically important parts in the document. Used for storage.

US Patent Application Publication No. 2004/0243560

Toshiyuki Shimizu, Makoto Onizuka, Masaharu Eda, Masatoshi Yoshikawa, Technology on XML Data Management and Stream Processing, IEICE Transactions J J90-D (2): 159-184, 2007 G. Navarro and V. Makinen, Compressed full-text indexes, ACM Computing Surveys 39 (1), 2007.

  By the way, it is expected that document structure information that does not guarantee a tree structure relationship between structures will increase in the future. For this reason, there is a need for a technique that enables a search based on a structural condition and a text condition without being bound by a tree structure relationship.

  However, results obtained by automatic extraction by a computer (for example, grammatical structure analysis results, document structure analysis results based on text semantic information (for example, important technologies / effects)) and manual marking results include the structure information. It does not necessarily satisfy the tree structure condition. For this reason, the existing XML search method cannot be used for a document including structural information that does not satisfy the tree structure condition.

  For the above reasons, a search function prepared by UIMA is used for searching tag information without any structural restrictions (Patent Document 1). However, this search method does not consider a hierarchical structure based on the inclusion relationship of tags. Therefore, in the search function prepared by UIMA, only a Boolean search for verifying whether or not the text specified as the search query is included in each tag is executed.

  Eventually, with the existing search function prepared for XML documents and the existing search function prepared by UIMA, for an annotated XML document, a search is performed in consideration of both the structural condition by XML and the structural condition by annotation. I could not.

  In the present invention, in consideration of the above-described problems, a structure formed by a structured document whose tag structure satisfies the tree structure condition and structure information of an arbitrary annotation associated with the document satisfies the tree structure condition. Even if it is not satisfied, it is possible to search in consideration of both structural conditions and text.

  This specification includes a plurality of inventions that solve the above-described problems. The invention as an example includes a processor that executes a program, a first storage area that stores the program, a structured document that satisfies the tree structure condition, and a second storage area that stores annotation data attached to the document In addition, the text of the structured document is assigned to the structure in which the root element of the DOM (Document Object Model) tree obtained individually from the inclusion relation of the tags of the structured document and the annotation data is included. A document structure list construction unit that generates a shared DOM tree, and a search processing unit that searches the text shared DOM tree for an element that matches a location path given as a search query.

  According to the present invention, it is possible to realize a search based on both structure information including an annotation given in an arbitrary format and text. Problems, configurations, and effects other than those described above will become apparent from the following description of embodiments.

1 is a diagram illustrating a configuration example of a structured document search device (first embodiment). FIG. The figure which shows an example of the program and data which are memorize | stored in a main memory (1st Example). The figure explaining an example of an annotation group (common to each Example). The figure which shows an example of a text sharing DOM tree (common to each Example). The figure explaining the flow of the pre-processing of a structured document search device (1st Example). The flowchart which shows the process example of a DOM tree construction part (1st Example). The flowchart which shows the process example of a document structure list construction part (1st Example). The flowchart which shows the process example of a parent-child relationship analysis / registration part (1st Example). The figure explaining the flow of the search process by a structured document search device (1st Example). The figure which shows an example of DOM DAG (2nd Example). The figure explaining an example of the path | pass DAG which integrated two DOM DAG, and a transposition index (2nd Example). The flowchart which shows the process example of the transposition index construction part (3rd Example). The flowchart which shows the process example of a depth allocation part (3rd Example). The flowchart which shows the process example of the path | pass DAG ID acquisition part (3rd Example). 12 is a flowchart illustrating a path DAG element generation / registration unit (third embodiment). The flowchart which shows the process example of a transposition index registration part (3rd Example). The figure explaining the example of a recording of DOM DAG (4th Example). The figure which shows the outline | summary of a search index (4th Example). The flowchart which shows the process example of a search index construction part (4th Example). The flowchart which shows the process example of a search index registration part (4th Example). The flowchart which shows the process example of the path | pass DAG ID registration part (4th Example). The flowchart which shows the process example of a location path search part (4th Example). The flowchart which shows the process example of an XML element search part (4th Example). The flowchart which shows the process example of an annotation element search part (4th Example). The figure which shows the outline | summary of an extended wavelet tree (6th Example). The flowchart which shows the process example of an extended wavelet tree construction part (6th Example). The flowchart which shows the process example of a rank calculation part (6th Example). The flowchart which shows the process example of a select calculation part (6th Example).

  Embodiments of the present invention will be described below with reference to the accompanying drawings. In addition, this invention is not limited to the Example mentioned later, A various deformation | transformation is possible in the range of the technical thought.

[First embodiment]
[Overview]
In this embodiment, a set of XML documents and a set of annotation data are pre-processed to create search data in advance, and an element that matches the search query is output as a search result by matching the search data with the search query. A structured document search apparatus will be described. In this embodiment, a text sharing DOM tree in which structural information of XML tags and annotation tags is integrated is used as search data.

[Device configuration]
FIG. 1-1 shows a configuration example of the structured document search apparatus 400. The structured document search device 400 is configured as a computer having a CPU (Central Processing Unit) 401, a main storage device (memory) 402, an auxiliary storage device 403A, and a user interface unit 406. The structured document search apparatus 400 is connected to an external network apparatus via a network 405 such as a LAN (Local Area Network).

  The CPU 401 is a central processing unit that executes a program stored in the main storage device 402. FIG. 1-2 shows an example of functional units and data realized through a program stored in the main storage device 402. In FIG. 1-2, not only the functional unit realized through the program used in the first embodiment, but also the functional unit realized by the program used in the other examples and the data used in each example. Also represents. For example, the CPU 401 executes a program to construct a DOM tree construction unit 409 that constructs a DOM tree from an XML document, a DOM tree construction unit 410 that constructs a DOM tree from annotation data, a document structure list construction unit 411, and a text sharing DOM tree construction. Unit 415, text data / text element list construction unit 417, text assignment unit 418, parent-child relationship analysis / registration unit 419, location path search unit 420, DOM DAG construction unit 422, transposed index construction unit 424, depth assignment unit 427, Path DAG ID acquisition unit 428, path DAG element generation / registration unit 429, path DAG ID registration unit 439, search index registration unit 440, XML element search unit 443, annotation element search unit 444, extended wavelet tree construction unit 451, search index Construction unit 454 It acts as a simple bit vector wavelet tree construction unit 455.

  The main storage device 402 is a storage device such as a RAM (Random Access Memory). The main storage device 402 stores the above-described program and the path DAG 423 used for executing the program. Further, if necessary, the main storage device 402 also temporarily stores an XML document set 407, an annotation data set 408, and a document structure list 412.

  The auxiliary storage device 403A is a storage device or storage medium such as an HDD that stores an XML document, annotation data, the above-described program, and the like.

  The removable medium 404 is a recording medium such as a CD-ROM or DVD that records an XML document, annotation data, or the like. Each data recorded in the auxiliary storage device 403A and the removable medium 404 is read to the main storage device 402 as necessary when the structured document search device 400 is activated.

  The user interface unit 406 is an input / output device (for example, a keyboard, a mouse, a display) that provides a user interface.

  The CPU 401 acquires an XML document and annotation data attached to the document as necessary from the main storage device 402, the auxiliary storage device 403A, the removable medium 404, or the external storage device 403B connected via the network 405. To do. Here, the external storage device 403B is a storage device such as an HDD or a storage medium. The network 405 may be a local area network or the Internet. The network 405 may be a wired network or a wireless network. The CPU 401 creates a search index 430 based on the XML document and annotation data acquired from these storage devices. The created search index 430 is stored in the main storage device 402.

  In the above description, an example in which the XML document and the annotation data are stored in any of the main storage device 402, the auxiliary storage device 403A, the removable medium 404, and the external storage device 403B on the network 405 has been described. It only needs to be stored on a readable / writable storage device. For example, the XML document may be stored in the auxiliary storage device 403A, and the annotation data may be stored in the main storage device 402.

  The CPU 401 executes a program corresponding to each functional unit described above, and operates as a functional unit that realizes a predetermined function. For example, the CPU 401 functions as the text sharing DOM tree construction unit 415 by operating according to the document structure construction program. The same applies to other programs. For example, the CPU 401 functions as the location path search unit 420 by operating according to the location path search program. The CPU 401 functions as the search index construction unit 454 by operating according to the search index construction program.

  Information such as programs and tables for realizing the functions of the location path search unit 420, the DOM DAG construction unit 422, and the search index construction unit 454 includes an auxiliary storage device 403A, a removable medium 404, a nonvolatile semiconductor memory, a hard disk drive, an SSD ( Solid State Drive) or a computer-readable non-transitory data storage medium such as an IC card, SD card, or DVD.

[Annotation data]
Next, annotation data will be described. An annotation is given by adding a tag to a text area in an XML document. A tag given by annotation is called an annotation tag. It is assumed that the annotation tag has a structure based on an inclusive relationship divided in advance into a group having a tree structure. An annotation tag group is called an annotation group, and an integer ID is assigned to each annotation group. Annotation tags belonging to different annotation groups do not need to satisfy the tree structure condition.

  FIG. 2 shows an example of annotations and annotation groups given to the XML document. In “annotation group 1”, an annotation tag “effect” is assigned to the text “improve durability” in the document, and an annotation tag “content” is assigned to the text “knife”. These tags satisfy the tree structure condition without overlapping each other. In “Annotation Group 2”, an annotation tag “target” is assigned to the text “medical” in the document, and an annotation tag “tool” is assigned to the text “medical knife”. Since these annotation tags are nested, they satisfy the tree structure condition.

  On the other hand, “content” that is an annotation tag belonging to “annotation group 1” and “tool” that is an annotation tag belonging to “annotation group 2” are not nested in each other, and the tree structure condition Does not meet. However, since “content” and “tool” are tags belonging to different annotation groups, there is no problem as annotation data.

  An annotation tag is composed of a set of four pieces of information given by “tag name, annotation group ID, start position of text area, end position of text area”. The annotation data is a set of data in which a set of four information is described for each annotation tag. As an example of annotation data, text data in which a tag name, an annotation group ID, a text region start position, and a text region end position, which are data of each annotation tag, are tab-separated can be considered in each line.

[XML elements, annotation elements, text elements]
The XML element is an element represented by a start tag and an end tag of each XML tag, and has a tag name and a position of the start tag and end tag in the text area. An annotation element is an element having a tag name, an annotation group ID, a start tag of each annotation tag, and a position of an end tag. The text element is an element that represents a text area, and includes a start position and an end position of the text area, and text included in the text area.

[DOM tree elements]
Elements constituting the DOM tree have a tag name, an annotation group ID, a text area start position, a text area end position, and a depth. In the case of an element using a normal XML tag, the annotation group ID is set to “0”. In the case of a text element, the annotation group ID is set to “−1”, and the text is held in the tag name portion.

[Overview of preprocessing]
Here, an overview of preprocessing executed by the structured document search apparatus 400 before search will be described. The pre-processing is executed by the CPU 401 functioning as the document structure list construction unit 411. The CPU 401 creates a text sharing DOM tree 416 as preprocessing.

  First, the CPU 401 acquires annotation data corresponding to an unprocessed XML document from the XML document set 407 and the annotation data set 408. Next, the CPU 401 executes a DOM tree construction program, and operates as a DOM tree construction unit 409 that constructs a DOM tree from an XML document, and a DOM tree construction unit 410 that constructs a DOM tree from annotation data. The CPU 401 functioning as the DOM tree construction units 409 and 410 creates a DOM tree of elements belonging to each annotation group of the DOM tree of the XML document and annotation data.

  Next, the CPU 401 executes a text sharing DOM tree construction program and functions as the text sharing DOM tree construction unit 415. Here, the CPU 401 assigns text to a structure in which the root elements of two DOM trees formed for the same text are shared, and creates a text sharing DOM tree 416. The text sharing DOM tree 416 constructed for each XML document and annotation data is held in the document structure list construction unit 411 as a data structure used for search.

[Text sharing DOM tree]
Next, the text sharing DOM tree 416 will be described. The text sharing DOM tree 416 is a data structure constructed from a DOM tree constructed based on XML tags and one or a plurality of DOM trees constructed based on tags belonging to each annotation group. It has a data structure that shares the root elements of. Here, the DOM tree based on the XML tag is constructed by the CPU 401 functioning as the DOM tree construction unit 409. The DOM tree based on the annotation tag is constructed by the CPU 401 functioning as the DOM tree construction unit 410. In the following description, the term “DOM tree” means a DOM tree constructed based on an XML tag or a DOM tree constructed based on an annotation tag.

  The text composing the XML document is delimited by an XML tag and an annotation tag, and a text element is formed for each delimited text area. In each DOM tree, the text element is assigned to the element deepest from the root element among the included elements. Each text region may be assigned to multiple DOM trees instead of a single DOM tree.

Figure 3 is created from the following sentences tagged with XML tags <p>, <mtd>, <fx>, <val>, <attr> and tags [A] and [T] belonging to the same annotation ID An example of a text sharing DOM tree is shown.
(Sentence before tagging)
“In the present invention, by using powdered coke, crude steel was produced and the efficiency was doubled.”
(Text after tagging)
“<P> In the present invention, [A] <mtd></mtd> using powder coke is used to produce <fx> [T] <obj> crude steel </ obj> [/ T] [/ A]. <Val> 2 times </ val><atr> Efficient </ attr></fx> was achieved. </ P>
As shown in FIG. 3, an edge is connected to <p> of the XML tag and [A] of the annotation tag in the root element of the text sharing DOM tree. In other words, the text sharing DOM tree has a structure in which the root element of the DOM tree by the XML tag and the DOM tree by the annotation tag belonging to the same annotation group are shared. The text is divided regardless of the XML tag and the annotation tag, and is divided into the case of the XML tag and the annotation tag, and is assigned to the element at the deepest position having the inclusion relation based on the inclusion relation of the text region. For example, in the example of FIG. 3, the text “crude steel” is assigned to both the XML tag <obj> and the annotation tag [T].

[Detailed preprocessing]
FIG. 4 shows the flow of data executed in connection with the preprocessing. The start of preprocessing is given to the CPU 401 through the user interface 406 (step S301). Further, the CPU 401 inputs the XML document set 407 and the annotation data set 408 from the auxiliary storage device 403A (step S302). The input XML document set 407 and annotation data set 408 are stored in the main storage device 402 as a work area.

  At this stage, the CPU 401 executes analysis processing as the text sharing DOM tree construction unit 415 and constructs the document structure list 412 (step S303).

  The CPU 401 (text sharing DOM tree construction unit 415) generates the text sharing DOM tree 416 based on the XML document as an element of the XML document set 407 and the annotation data 408 as an element of the annotation data set 408 corresponding to the XML document. Generate. Details of the preprocessing executed by the CPU 401 (text sharing DOM tree construction unit 415) will be described later. When the preprocessing ends, the CPU 401 outputs the generated text sharing DOM tree 416 as the document structure list 412 to the auxiliary storage device 403A (step S304).

[DOM tree construction unit 410 for annotation data]
FIG. 5 is a flowchart illustrating a processing operation example of the CPU 401 functioning as the DOM tree construction unit 410 that constructs the DOM tree from the annotation data.

  The CPU 401 (DOM tree construction unit 410) reads the input annotation data file, and prepares a set AS of four sets of data “tag name, annotation group ID, text region start position, text region end position” (step). S401). The CPU 401 sets the largest annotation group ID in the set AS to “g” (step S402). Next, the CPU 401 sets “1” to the variable i (step S403). Next, the CPU 401 determines whether or not the variable i is “g” or less, and repeats steps S405 to S413 described later until the variable i becomes larger than “g” (step S404).

  If an affirmative result is obtained in step S404, the CPU 401 sets the list of elements whose annotation group ID is the variable i from the set AS to AL (step S405). Next, the CPU 401 sorts the elements of the list AL in ascending order of the text area start position, and sorts elements having the same text area start position in descending order of the end position of the text area (step S406).

  Subsequently, the CPU 401 prepares a DOM tree AT including only root elements, and sets the root element to v (step S407). Here, the CPU 401 sets 1 to the variable j (step S408). Next, the CPU 401 repeats steps S410 to S412 described later until the variable j exceeds the length (number of elements) of the list AL (step S409). After the repetition is completed, “1” is added to the variable i and the step is repeated. The process returns to S404 (step S413).

  When a positive result is obtained in the previous step S409, the CPU 401 determines that the text area of the jth element of the list AL (the area given by the text area start position and the text area end position) is in the root element v. The process of setting the parent element of the root element v to v is repeated until it is included in (text area start position and text area end position) (step S410).

  Thereafter, the CPU 401 creates a DOM tree element having a tag name, an annotation group ID, a text area start position, and a text area end position of the jth element of the list AL, and uses the DOM tree AT as a child element of the root element v. (Step S411). Thereafter, the CPU 401 adds “1” to the variable j and returns to step S409 (step S412).

  For each annotation group, the CPU 401 sorts the elements in advance based on the start position and end position of the text area, and then constructs a DOM tree of annotation data by applying the method described above. Although the DOM tree is an ordered tree, sibling elements are sorted in ascending order at the start position of the text area by adding elements by the method described above.

[DOM tree construction unit 409 for XML document]
As described above, the CPU 401 also functions as the DOM tree construction unit 409 that constructs a DOM tree from an XML document. The CPU 401 serving as the DOM tree construction unit 409 analyzes the inclusion relationship of the tags attached to the input XML document and constructs a DOM tree. The DOM tree of the XML document can be constructed by the method described in Non-Patent Document 1. The constructed DOM tree does not include information on the start position and end position of the text area corresponding to each tag.

  In the present embodiment, the CPU 401 calculates the start position and the end position in the text area for the text element assigned to the DOM tree constructed for the XML document. Next, the CPU 401 deletes the text element while giving the calculated position information to each element, and creates a text in which character strings held by the text element are connected.

  Here, “t” is an empty text. The CPU 401 scans the constructed DOM tree from the root element, records the text length corresponding to the text element, and records the start position in the front order and the end position in the back order. After scanning each text element, the CPU 401 deletes the text element and adds a character string held by the deleted text element to the text “t”. Finally, the CPU 401 outputs the constructed DOM tree and text t, and ends a series of processing.

[Document Structure List Building Unit 411]
FIG. 6 is a flowchart illustrating an example of processing executed by the CPU 401 functioning as the document structure list construction unit 411.

  First, the CPU 401 inputs an XML document set 407 and an annotation data set 408 (step S501). Next, the CPU 401 initializes the document structure list 412 to an empty list (step S502). Thereafter, the CPU 401 sets “1” in the variable i (step S503). Next, the CPU 401 initializes the text data list to be empty (step S504).

  Thereafter, the CPU 401 determines whether or not all the pairs of XML documents and annotation data included in the XML document set 407 and the annotation data set 408 have been processed (step S505). Until a positive result is obtained in this determination process, the CPU 401 repeatedly executes processes in steps S506 to S510 described later.

  If a negative result is obtained in step S505, the CPU 401 reads an unprocessed XML document and annotation data pair (step S506). Next, the CPU 401 functions as a DOM tree construction unit 409 for XML documents and a DOM tree construction unit 410 for annotation data, and creates corresponding DOM trees (step S507).

  Thereafter, when the CPU 401 inputs the DOM tree obtained from the XML document and the DOM tree obtained from the tag belonging to each annotation group, the CPU 401 functions as a text sharing DOM tree construction unit 415 to be described later, and the text sharing DOM tree 416 is displayed. A list N of elements constituting the created text sharing DOM tree 416 is obtained (step S508). Next, the CPU 401 adds the list N to the document structure list (text sharing DOM tree list) 412 (step S509).

  Next, the CPU 401 determines that the read XML document and annotation data have been processed, and returns to step S505 (step S510).

[Text sharing DOM tree construction unit 415]
The CPU 401 functioning as the text sharing DOM tree construction unit 415 inputs a DOM tree made up of XML elements, and a DOM tree made up of text in the XML document and elements of each annotation group. Here, the CPU 401 prepares a list N of elements other than the root element of each DOM tree.

  The CPU 401 inputs the text in the list N and the XML document to the text data / text element list construction unit 417 and updates the text data list 414 and the text element list 413.

  Thereafter, the CPU 401 inputs a DOM tree including a text element list 413, XML elements, and elements of each annotation group. The CPU 401 functioning as the text assignment unit 418 assigns the text element to each element as a child element. The CPU 401 adds each element of the text element list 413 to the list N. Further, the CPU 401 shares the root element of each DOM tree into one, and adds the common root element to the top of the list N. Finally, the CPU 401 outputs the list N and ends the text sharing DOM tree creation process.

[Text Data / Text Element List Building Unit 417]
The CPU 401 functioning as the text data / text element list construction unit 417 inputs the list N and the text t. The CPU 401 takes out the start position and end position of the text area of each element in the list N, and designates a list composed of numerical values sorted in ascending order as S. The CPU 401 removes the portion where the numerical value is duplicated in the list S. When the top value of the list S is not 0, the CPU 401 adds 0 to the top. If the last value in the list S is the same as the text t, the CPU 401 deletes the last value. The CPU 401 adds the text t and the list S as text data to the end of the text data list 414.

  The CPU 401 initializes the text element list 413 to be empty. Each value in the list S gives the start position and end position of the text area. Therefore, the CPU 401 creates elements of the DOM DAG 421 in order from the top element of the list S, with the start position of the text area being the value of the element currently being viewed, the end position being the value of the next element, and the tag name being #. The text element list 413 is sequentially added to the end. In the case of the last element in the list S, the next element does not exist. Therefore, the CPU 401 sets the length of the text t at the end position of the text area.

[Text allocation unit 418]
Each element of the text element list 413 does not have an inclusion relationship because the text areas do not overlap each other. For this reason, the CPU 401 functioning as the text assignment unit 418 can create a DOM tree in which the text elements are siblings based on each element of the text element list 413 and the root element. Let the created DOM tree be Tt. The CPU 401 registers a parent outside the annotation group with respect to the DOM tree Tt through a function as a parent-child relationship analysis / registration unit 419 described later from the DOM tree of each annotation group.

[Inclusive relation between elements]
In the present embodiment, the inclusion relationship between the XML element or annotation element and the text element is assumed to follow the following rules. If the text area of the XML element or annotation element includes or is the same as the text area of the text element, the XML element or annotation element shall include the text element. In other cases, there is no inclusion relationship.

[Parent-child relationship analysis / registration unit 419]
FIG. 7 is a flowchart illustrating an example of processing executed by the CPU 401 functioning as the parent-child relationship analysis / registration unit 419.

First, the CPU 401 inputs the DOM tree T and the DOM tree U (step S601).
Next, the CPU 401 sets a set of elements of the DOM tree U as V (step S602), and determines whether V is empty (step S603). Steps S604 to S608 described later are repeated until V becomes empty.

  The element v is extracted from V and deleted from V (step S604). Among the elements of the DOM tree T, the CPU 401 sets the element u that has the deepest depth from the root among the elements including v (step S605). It is determined whether u is a root element of the DOM tree T (step S606). If it is not a root element, the CPU 401 registers u as a parent element outside the annotation group of v, and returns to step S603 (step S607). .

[Overview of search operation]
Next, an outline of search processing executed in the structured document search apparatus 400 will be described. The search process is executed by the CPU 401 functioning as a location path search unit 420 described later. The CPU 401 functioning as the location path search unit 420 follows a text sharing DOM tree constructed from each XML document and annotation data along the location path, and acquires an element that matches the search query as a search result.

  FIG. 3 shows a case where an element having a common location path “/ p / fx / obj” and location path “/ A / T” is searched for the text sharing DOM tree. In the case of the example in FIG. 3, the location path “/ p / fx / obj” indicates that the element assigned under the tag <obj> under the tag <fx> under the tag <p> under the root element. The location path “/ A / T” represents an element allocated under the tag [T] under the tag [A] under the root element. In FIG. 3, these two location paths are represented by dotted arrows. As a result, the common element is “crude steel” which is a text element.

[Details of search operation]
FIG. 8 shows the flow of data when search processing is executed in structured document search apparatus 400. It is assumed that the CPU 401 has previously read the document structure list 412 (text sharing DOM tree 416 in this embodiment) used for the search from the auxiliary storage device 403A to the main storage device 402 (step S401). .

  In this state, the user inputs a location path as a search query to the structured document search device 400 (specifically, the CPU 401) through the user interface 406 (step S402).

  Then, the CPU 402 functioning as the location path search unit 420 accesses the text sharing DOM tree 416 in the document structure list 412 and calculates the location of the element that matches the location path specified as the search query (step S403). Thereafter, the CPU 401 outputs a set of elements that match the search query to the user interface 406 (step S405).

[Location path search unit 420]
Finally, the operation of the CPU 401 functioning as the location path search unit 420 will be described. The head of the list of each element constituting the document structure list 412 is a root element of the text sharing DOM tree. Accordingly, the CPU 401 obtains an element of the text sharing DOM tree that matches the search query by tracing the text sharing DOM tree along the location path from the root element of each text sharing DOM tree.

[Effect of Example]
The structured document search apparatus 400 according to the present embodiment uses, as preprocessing, a text in which a root element is shared between a DOM tree constructed based on an XML tag and a DOM tree constructed based on a tag belonging to an annotation group. A shared DOM tree 416 is generated. The text sharing DOM tree 416 includes the structure of each DOM tree starting from a common root element. Therefore, even when an annotation is added to an XML document in an arbitrary format, it is possible to perform a search in consideration of both the XML hierarchical structure and the annotation hierarchical structure.

[Second Embodiment]
In this embodiment, an inclusion relationship between different types of elements such as XML elements and annotation elements or annotation elements belonging to different annotation groups is defined. For this purpose, in this embodiment, a DOM DAG (Directed Acyclic Graph) obtained by extending the structure of the text sharing DOM tree in the first embodiment is used. The basic configuration of the structured document search apparatus 400 according to the present embodiment is the same as that of the first embodiment. That is, the basic configuration is the configuration shown in FIGS. 1-1 and 1-2. However, in this embodiment, the DOM DAG construction unit 422 is used instead of the text sharing DOM tree construction unit 415.

[Overview of preprocessing]
As described above, in this embodiment, the structure search using the DOM DAG in which the inclusion relation of the text area between the XML element and the annotation element and between the elements belonging to different annotation groups is also considered as the parent-child relation is described. To do. With the introduction of DOM DAG, a structured document search apparatus capable of executing a search in consideration of the inclusion relationship between different types of elements is realized.

[DOM DAG]
Here, the DOM DAG used in the present embodiment will be described. The DOM DAG is a data structure in which inclusion relationships between different types of elements such as XML tags and tags belonging to different annotation groups are described in a text sharing DOM tree. That is, it is a data structure in which a parent-child relationship based on an inclusion relationship is described between DOM trees shared by root elements.

  In the DOM DAG, for example, among the elements of the DOM tree T1 including the elements of the DOM tree T2, it is treated as having a parent-child relationship with the element at the deepest position from the root element of the DOM tree T1, and the DOM tree T1 and A link is established between the DOM trees T2. Thereby, the inclusion relationship from the element of the DOM tree T1 to the element of the DOM tree T2 is expressed.

  FIG. 9 shows an example of a DOM DAG constructed based on the text sharing DOM tree 416 shown in FIG. In the case of FIG. 9, the link from the tag <fx>, which is an XML tag, to the tag [T], which is an annotation tag, and the link from the tag [T], which is an annotation tag, to a tag <obj>, which is an XML tag, Parent-child relationships are also considered between different types of tags.

[Inclusive relation of elements in DOM DAG]
The inclusion relationship of the elements in the DOM tree or DOM DAG shall follow the following rules.
(1) The root element includes any element other than the root element.
(2) When the text region start position and end position of the XML element and annotation element are the same, the XML element includes the annotation element.
(3) When the text region start position and end position of annotation elements are the same, an element with a small annotation group ID includes an element with a large annotation group ID.
(4) When the text region start position and end position are the same for the text element and other elements other than the text element, the latter includes the former.
(5) When the inclusion relation is not determined by (1) to (4), the inclusion relation of the element is determined from the inclusion relation of the text region in the element. However, when the text area of the text element includes the text area of another element, it is assumed that there is no element inclusion relationship.
(6) When the inclusion relationship is not determined by (1) to (5), it is assumed that there is no mutual inclusion relationship.

[DOM DAG construction unit 422]
The CPU 401 functioning as the DOM DAG construction unit 422 receives as input the DOM tree constructed from the XML elements, the text in the XML document, and the DOM tree constructed from the elements of each annotation group.

  The CPU 401 functioning as the parent-child relationship analysis / registration unit 419 assigns a parent outside the annotation group to all DOM tree pairs of the annotation group including the XML element. Here, the CPU 401 prepares a list N of elements other than the root element for each DOM tree. The CPU 401 inputs the text in the list N and the XML document to the text data / text element list construction unit 417 and updates the text data list 414 and the text element list 413.

  When the CPU 401 functioning as the text assigning unit 418 inputs a text element list 413, an XML element, and a DOM tree composed of elements of each annotation group, the CPU 401 assigns the text element to each element of the DOM tree as a child element. The CPU 401 adds each element of the text element list 413 to the list N and assigns depth information to each element. The CPU 401 establishes a parent-child relationship link to the elements in the parent element list outside the annotation group possessed by each element of the DOM tree. Further, the CPU 401 shares the root element of each DOM tree into one, and adds the common root element to the top of the list N. Thereafter, the CPU 401 outputs the list N and ends the creation process of the DOM DAG.

[Effect of Example]
The structured document search apparatus 400 according to the present embodiment creates a DOM DAG that defines an inclusion relationship between elements of different DOM trees constituting the text sharing DOM tree 416 described in the first embodiment as preprocessing. Therefore, by using the structured document search apparatus 400 according to the present embodiment, in addition to the effects of the first embodiment, it is possible to perform a search in consideration of an inclusion relationship (parent-child relationship) between different types of elements.

[Third embodiment]
As described above, if DOM DAG is used, a search using the structural relationship between different types of tags becomes possible. However, it is inefficient to trace all constructed DOM DAGs from the root element when searching for a location path.

  Therefore, in this embodiment, a path DAG that is a data structure in which the structures of a plurality of DOM DAGs are aggregated is defined. Furthermore, by making an element in the path DAG an entry and performing a search using a transposed index with the element in the DOM DAG as a value, an efficient search using the location path as a search query is enabled.

  Also in this embodiment, the basic configuration of the structured document search apparatus 400 is the same as that of the first embodiment. That is, the basic configuration is the configuration shown in FIGS. 1-1 and 1-2. However, in this embodiment, the functions of the DOM DAG construction unit 422 and the location path search unit 420 are expanded.

[Overview of preprocessing]
In this embodiment, the transposed index construction unit 424 executes preprocessing. The CPU 401 functioning as the transposed index construction unit 424 initializes the path DAG 423 to a data structure including only root elements, and constructs a DOM DAG based on annotation data corresponding to each XML document.

  The CPU 401 functioning as the path DAG ID acquisition unit 428 determines whether or not the structure is already registered in the path DAG based on the tag name and parent element of each element constituting the DOM DAG. When the structure to be determined is already registered in the path DAG, the CPU 401 gives the structure a path DAG ID that is an ID of an element in the corresponding path DAG. On the other hand, when the structure to be determined is not registered, the CPU 401 functions as the path DAG element generation / registration unit 429, generates a new element for the path DAG 423, and generates a new element for the generated element. You can get a pass DAG ID. After acquiring the path DAG ID, the CPU 401 adds each element to the entry corresponding to the acquired path DAG ID of the transposition index 425.

  FIG. 10 shows an example of a path DAG and a transposed index 425 generated after registration of two DOM DAGs. As shown in FIG. 10, the path DAG 423 is constructed so that elements having the same set of parent nodes are shared between the DOM DAG constructed from the XML document 1 and the DOM DAG constructed from the XML document 2. . In the figure, the elements shown in white are XML elements, and the elements shown in black are annotation elements.

  However, in the case of an element such as element c in which the parent set relationship is different between the two documents, it is registered as a different element on the path DAG 423. In FIG. 10, “c: 1” and “c: 2” are distinguished and registered.

  In addition, the element d has only the element c as the parent element, and it seems that the set of parents is common. However, the element c on the path DAG is registered as a different element as described above. For this reason, the element d is also registered as a different element on the path DAG. Each element of the DOM DAG is assigned a number that is a combination of the document order and the tag appearance order in the document. The number of each element is recorded in the path DAG ID entry of the corresponding path DAG element in the transposed index 425.

  In FIG. 10, the structure of the transposed index 425 corresponding to the path DAG 423 is also described as the relationship between the ID and the tag number. A method for generating this transposed index will be described in the next section.

[Transposition index construction unit 424]
FIG. 11 is a flowchart showing the processing operation of the CPU 401 functioning as the transposed index construction unit 424.

  First, the CPU 401 inputs an XML document set 407 and an annotation data set 408 (step S1001). Next, the CPU 401 initializes the DOM DAG list to an empty list (step S1002). Subsequently, the CPU 401 initializes the transposed index 425 to an empty table (step S1003). Further, the CPU 401 sets the variable i to “1” (step S1004). Next, the CPU 401 initializes the text data list to be empty (step S1005).

  Thereafter, the CPU 401 determines whether or not all the pairs of XML documents and annotation data included in the XML document set 407 and the annotation data set 408 have been processed (step S1006). Until a positive result is obtained in this determination process, the CPU 401 repeats the processes of steps S1007 to S1013 described later.

  The CPU 401 functioning as the DOM DAG construction unit 422 reads an unprocessed XML document and annotation data pair (step S1007). Here, the CPU 401 functions as the DOM tree construction unit 409 for the XML document and the DOM tree construction unit 410 for the annotation data, and creates a DOM tree from each of the XML document and the annotation data (step S1008).

  Next, the CPU 401 functions as a DOM DAG construction unit 422 to be described later, creates a DOM DAG 421 from the DOM tree obtained from the XML document and the DOM tree obtained from the tag belonging to each annotation group, and configures the DOM DAG 421. An element list N is obtained (step S1009).

  Subsequently, the CPU 401 inputs the list N to a DOM DAG element list sorting unit 426 described later and sorts the list N (step S1010). Further, the CPU 401 inputs the list N and the variable i to the transposed index registration unit 440 and registers each element in the transposed index 425 (step S1011). Thereafter, the CPU 401 adds the list N to the DOM DAG list (step S1012). In addition, the CPU 401 determines that the read XML document and annotation data have been processed, and returns to step S1006 (step S1013).

[DOM DAG element list sort unit 426]
Here, the processing operation of the DOM DAG element list sorting unit 426 that executes the processing of step S1010 will be described. Of course, the function as the DOM DAG element list sorting unit 426 is realized through execution of a program by the CPU 401. The CPU 401 functioning as the DOM DAG element list sorting unit 426 receives a list N of DOM DAG elements as an input. Next, the CPU 401 rearranges the elements in the list N in the order of appearance in the document based on the text region start position and the inclusion relationship. If the XML elements are rearranged in the order of the DOM tree corresponding to each annotation group in advance and the rearranged elements are merged in the manner of merge sort, the elements in the list N can be efficiently sorted. it can. The arrangement of elements shall follow the following rules:
(1) The root element comes before any other element.
(2) When the text region start position comes before the previous element or when the text region start position is the same, the containing element comes before.

[Depth allocation unit 427]
Here, the function of the CPU 401 functioning as the depth assignment unit 427 will be described. FIG. 12 is a flowchart illustrating a processing example of the depth assignment unit 427.

  First, the CPU 401 receives a list N composed of elements of the DOM DAG 421 (step S1101). Next, the CPU 401 sets the depth of the element at the deepest position in the XML document as D and sets the array of lengths D as E (step S1102). Next, the CPU 401 sets variable i to 1 and variable d to 0 (step S1103). Thereafter, the CPU 401 determines whether or not the variable i is equal to or shorter than the length of N (step S1104). The CPU 401 repeats steps S1105 to S1113 described later until it is determined that the variable i is greater than the length of N.

  If a positive result is obtained in step S1104, the CPU 401 sets the i-th element of the list N to v (step S1105). Next, the CPU 401 determines whether v is an XML element or a text element (step S1106). Here, when v is an XML element or a text element, the CPU 401 sets the depth of the DOM DAG 421 from the root element to d (step S1107). Further, the CPU 401 sets the text area end position of v in the d-th element of E, and returns to step S1104 (step S1108).

  On the other hand, if it is determined in step S1106 that v is neither an XML element nor a text element, the CPU 401 determines whether v is an annotation tag start element (step S1109). If it is determined that v is the start element of the annotation tag, the CPU 401 sets the text area start position of v in the variable e (step S1110). In contrast, if it is determined in step S1109 that v is not the start element of the annotation tag, the CPU 401 sets the end position of the text area of v in the variable e (step S1111).

  Regardless of whether the v is the text region start position or the text region end position, the CPU 401 sets the variable d to 1 until the variable d becomes 1 or the d-1th element of E becomes larger than the variable e. Is subtracted (step S1112). Thereafter, the CPU 401 sets the depth of v to d, adds 1 to the variable i, and returns to step S1104 (step S1113).

[Pass DAG ID acquisition unit 428]
Here, the processing function of the path DAG ID acquisition unit 428 that acquires the path DAG from the DOM DAG will be described. FIG. 13 is a flowchart illustrating a processing example of the CPU 401 functioning as the path DAG ID acquisition unit 428.

  First, the CPU 401 inputs a list N of elements of the DOM DAG 421 (step S1201). Next, the CPU 401 sets a variable i to 1 (step S1202). Thereafter, the CPU 401 determines whether or not the variable i is equal to or less than the length of N, and repeats steps S1204 to S1213 described later until it is determined that the variable i is greater than the length of N (step S1203).

  When the variable i is equal to or shorter than the length of the list N, the CPU 401 sets the i-th element of the list N as v (step S1204). Next, the CPU 401 determines whether or not the element v is an annotation end tag element (step S1205). When a positive result is obtained as the determination result, the CPU 401 adds 1 to the variable i and returns to step S1203 (step S1206). On the other hand, when a negative result is obtained in the determination process in step S1205, the CPU 401 sets a set of parent elements of the element v in the DOM DAG 421 as V (step S1207). Further, the CPU 401 sets a set of elements of the path DAG 423 corresponding to each element of the set V as P (step S1208). Further, the CPU 401 sets the set of elements of the path DAG 423 having the same tag name as the element v among the common child elements among the elements of the path DAG 423 belonging to the set P as I (step S1209).

  Here, the CPU 401 determines whether or not there is an element in the set I whose parent element set is the same as the set P (step S1210). If a positive result is obtained in this determination process, the CPU 401 registers the path DAG ID of the element in the element v, and the process returns to step S1203 (step S1211). On the other hand, if a negative result is obtained in the determination process in step S1210, the CPU 401 inputs the element v and the set P to a path DAG element generation / registration unit 429 described later (step S1212). Thereafter, the CPU 401 adds 1 to the variable i and returns to step S1203 (step S1213).

[Path DAG element generation / registration unit 429]
Here, the processing function of the CPU 401 as the path DAG element generation / registration unit 429 used in step S1212 will be described. FIG. 14 is a flowchart illustrating a processing example of the CPU 401 functioning as the path DAG element generation / registration unit 429.

  The CPU 401 inputs the element v of the DOM DAG 421 and the element P of the path DAG 423 (step S1301). Here, the CPU 401 sets the depth held by the element v to d (step S1302).

  Next, the CPU 401 determines whether or not the element v is an annotation element (step S1303). When the element v is an annotation element, the CPU 401 gives (2, d, AI) to the element v as a path DAG ID, and adds 1 to AI (step S1304). Thereafter, the CPU 401 creates a path DAG element having a path DAG ID held by the element v and sets it as a child element of each element of the set P (step S1305).

  On the other hand, when a negative result is obtained in step S1303 (that is, when the element v is an XML element), the CPU 401 determines whether the tag name of the element v is “#” (step S1306).

  When the tag name of the element v is #, the CPU 401 gives (1, d, XI [d]) to the element v as a path DAG ID (step S1307). On the other hand, if the tag name of the element v is not #, the CPU 401 gives (0, d, XI [d]) to the element v as a path DAG ID (step S1308). After any path DAG ID is given to the element v, the CPU 401 adds 1 to XI [d] (step S1309).

[Transposition index registration unit 442]
Next, the processing operation of the transposed index registration unit 442 will be described. FIG. 15 is a flowchart showing processing of the CPU 401 functioning as the transposed index registration unit 442.

  First, the CPU 401 inputs a DOM DAG element list N and a document number n (step S1401). Next, the CPU 401 sets 1 to the variable i (step S1402). Subsequently, the CPU 401 determines whether or not the variable i is equal to or shorter than the length of the list N (step S1403). The CPU 401 repeats steps S1404 to S1409 described later until it is determined that the variable i exceeds the length of the list N.

  When the variable i does not exceed the length of the list N, the CPU 401 determines whether the element v is a root element (step S1404). When the element v is the root element, the CPU 401 adds 1 to the variable i and returns to step S1403 (step S1409). On the other hand, if the element v is not a root element, the CPU 401 inputs a variable v to a path DAG ID acquisition unit 428 described later, and acquires a path DAG IDj held by the variable v (step S1405).

  Thereafter, the CPU 401 determines whether or not there is an entry corresponding to the variable j in the transposed index 425 (step S1406). If there is no corresponding entry, the CPU 401 creates an entry corresponding to the variable j (step S1408). Thereafter, the CPU 401 adds a (n, i) tuple to the entry corresponding to the variable j (step S1407). Thereafter, the CPU 401 adds 1 to the variable i and returns to step S1403 (step S1409).

[Overview of search operation]
The search operation according to the present embodiment proceeds as follows. In the case of the present embodiment, the search based on the location path is executed by the CPU 401 as the location path search unit 420 based on the transposed index 425. The CPU 401 as the location path search unit 420 traces the path DAG along the location path, and acquires the path DAG ID of the path DAG element that matches the location path structure.

  The CPU 401 searches the transposition index 425 based on the acquired path DAG ID, and obtains the tag number of the DOM DAG element that matches the location path from the DOM DAG list. Next, the CPU 401 acquires a DOM DAG element specified by this tag number as a search result.

  The above processing operation will be described using a specific example. Here, FIG. 10 is referred. FIG. 10 shows an element for which a search for an element that matches the location path “/ a / b / #” is executed using the path DAG 423 and the transposed index 425. In this case, the CPU 401 follows the location path on the path DAG (structure diagram shown in the lower left), and obtains (1, 3, 1) as the path DAG ID. Next, the CPU 401 searches for an entry corresponding to (1, 3, 1) from the transposed index 425 (table shown in the lower right). In the example of FIG. 10, (1, 5) and (2, 4), which are tag numbers of the DOM DAG element, are obtained as indicated by broken-line arrows. Next, the CPU 401 acquires an element corresponding to the tag number from the DOM DAG of the document 1 and the DOM DAG of the document 2.

[Location path search unit 420]
Here, processing of the CPU 401 functioning as the location path search unit 420 will be described. The CPU 401 follows the path DAG 423 along the location path, and sets the path DAG ID corresponding to the reached element as the variable i. Next, the CPU 401 acquires an entry E corresponding to the path DAG IDi from the transposed index 425. Each element in entry E is a set of the location of the list of elements in the DOM DAG in the DOM DAG list and the location of the elements in the DOM DAG list. The location path search unit 420 acquires all the corresponding DOM DAG elements from the transposed index 425 and outputs them.

[Effect of Example]
In the structured document search apparatus 400 according to the present embodiment, by defining a path DAG in which the structures of a plurality of DOM DAGs are defined, search efficiency can be improved as compared with the above-described embodiment.

[Fourth embodiment]
Here, a holding form on the computer of the DOM DAG421 will be considered. In the C language or the like, the structure information is expressed as a pointer. For this reason, when the structure of the DOM DAG 421 is complicated, a large number of pointers are extended between elements, and more memory is required than the original XML document and annotation data. In this embodiment, a method for expressing the structure of the DOM DAG using the path DAG and the numerical sequence data will be described.

  Note that the structured document search apparatus 400 according to the present embodiment uses the start tag of the XML document and the element number assigned to the search query based on the element numbers assigned in the order of appearance for the start element and the end element that appear in the annotation data. Search for elements corresponding to the start and end locations.

[Overview of preprocessing]
The pre-processing according to the present embodiment is executed by the CPU 401 functioning as the search index construction unit 424. As described in the above embodiment, the search index 430 describes the structure of the DOM DAG 421 using the path DAG and the sequence data. Therefore, it is not necessary to store the DOM DAG 421 for the annotation data corresponding to each XML document in the main storage device 402.

  First, the CPU 401 constructs a DOM DAG 421 for annotation data corresponding to each XML document. Next, the CPU 401 functions as the path DAG ID acquisition unit 428 and acquires the path DAG ID of each element of the constructed DOM DAG 421. Thereafter, the CPU 401 registers the acquired path DAG ID in the sequence data in order.

  FIG. 16 shows how the DOM DAG shown in FIG. 10 is recorded as sequence data. As shown in the upper left column, each element of the DOM DAG 421 is assigned a serial number in the order of appearance. In the case of FIG. 16, each element of the DOM DAG of the document 1 is assigned a serial number from “1” to “7” in the order of appearance, and each element of the DOM DAG of the document 2 is “8” in the order of appearance. "To" 15 "are assigned serial numbers. Further, as shown in the upper right column, in each element of the path DAG 423 in which the two DOM DAGs 421 are aggregated, the sequence DAG ID is recorded in the order of appearance of each layer.

[Search index 430]
FIG. 17 shows an overview of the search index 430. The search index 430 includes a path DAG 423 in which the structures of a plurality of DOM DAGs are aggregated, an ID assigned to each element of the path DAG 423 assigned to each element of the DOM DAG, a sequence data group registered in the appearance order of the elements, and a bit string It consists of a data group and a text data list 414.

  The sequence data group includes an annotation element determination bit string 431, a text element determination bit string 432, an XML element depth number string 433, a depth-specific ID string list 434, an annotation end tag determination bit string 435, an annotation start tag ID string 436, and an annotation end tag. An ID string 437 and an annotation element depth number string 438 are included. The text data list 414 includes a text in which all character strings in each XML document are connected in the order of appearance, and a list of text division positions separated by the XML tag and the annotation tag.

[Search index construction unit 454]
FIG. 18 is a flowchart illustrating a processing example of the CPU 401 functioning as the search index construction unit 454.

  First, the CPU 401 receives an XML document set 407 and an annotation data set 408 as input (step S1701). Next, the CPU 401 determines the annotation element determination bit string 431, the text element determination bit string 432, the XML element depth number string 433, the annotation end tag determination bit string 435, the annotation start tag ID string 436, the annotation end tag ID string 437, and the annotation element The depth sequence 438 is initialized to an empty sequence (step S1702).

  Next, when the depth of an element at the deepest position in the XML document included in the XML document set 407 is D, the CPU 401 sets D empty number sequences in the depth-specific ID column list 434 ( Step S1703).

  Thereafter, the CPU 401 initializes the path DAG 423 to a graph having only the root element, and gives (0, 0, 1) as the path DAG ID to the root element (step S1704). Further, the CPU 401 initializes each element of the numerical sequence XI having the number XD and the length D and the number AI to 0 (step S1704).

  Further, the CPU 401 initializes the text data list to be empty (step S1705).

  Thereafter, the CPU 401 determines whether or not all pairs of the XML document and annotation data included in the XML document set 407 and the annotation data set 408 have been processed (step S1706). Until a positive result is obtained in this determination process, the CPU 401 repeatedly executes processes in steps S1707 to S1713 described later.

  If a negative result is obtained in step S1706, the CPU 401 reads an unprocessed XML document and annotation data pair (step S1707). From the XML document, the DOM tree construction unit 409 from the XML document creates a DOM tree from the annotation data by the DOM tree construction unit 410 from the annotation data (step S1708).

  Next, when a DOM tree obtained from an XML document and a DOM tree obtained from a tag belonging to each annotation group are input, the CPU 401 creates a DOM DAG 421 through a function as a DOM DAG construction unit 422 to be described later. A list N is obtained (step S1709).

  Thereafter, the CPU 401 inputs the list N to the DOM DAG element list sorting unit 426 and sorts it (step S1710). Further, the CPU 401 inputs the list N to the annotation end tag insertion unit 441 described later (step S1711). Next, the CPU 401 inputs the list N to the search index registration unit 440 described later (step S1712). The CPU 401 determines that the read XML document and annotation data have been processed, and returns to step S1706 (step S1713).

[Annotation end tag element]
An annotation end tag element is an element indicating an annotation end tag, and holds a corresponding annotation element, depth, and path DAG ID. The annotation end tag element is used to indicate the end position of the annotation tag in the list in which the elements of the DOM DAG 421 are sorted.

[Annotation end tag insertion unit 441]
The CPU 401 functioning as the annotation end tag insertion unit 441 receives a list N of elements of the DOM DAG 421 as an input. Here, the CPU 401 prepares a list L of empty annotation elements.

  The CPU 401 scans the elements of the list N in order from the top. When the element of the list N is an annotation element, an end element of the annotation tag is created, and the corresponding annotation element is recorded, and then added to the end of the list L. After scanning the list N, the CPU 401 inserts elements in the list L into the list N in the manner of merge sort, and merges the list L into the list N. The order of sorting shall follow the following rules.

When sorting the elements of the DOM tree, the elements are sorted in descending order according to the following rules.
(1) The root element comes before any other element.
(2) In the comparison between the element in the list N and the annotation end tag element, when the former text area start position is the same as the latter text area end position, if the former includes an annotation element held in the latter, Come forward. If not, the latter comes first.
(3) In the comparison between the element in the list N and the annotation end tag element, when the former text area end position is the same as the latter text area end position, if the annotation element corresponding to the latter includes the former, the former is I come to. If not, the latter comes first.

[Search index registration unit 440]
FIG. 19 is a flowchart illustrating a processing example of the CPU 401 functioning as the search index registration unit 440.

  The CPU 401 receives a list N composed of elements of the DOM DAG 421 (step S1801). Next, the CPU 401 sets 1 to the variable i (step S1802). Thereafter, the CPU 401 determines whether the variable i is equal to or shorter than the length of the list N (step S1803). The CPU 401 repeats steps S1804 to S1811 described later until the variable i exceeds the length of the list N.

  When the variable i is equal to or shorter than the length of the list N, the CPU 401 sets the i-th element of the list N as v (step S1804). Here, the CPU 401 determines whether or not the element v is an end element of the annotation tag (step S1805). If an affirmative result is obtained, the CPU 401 obtains the path DAG IDj of the start element corresponding to the element v, and sets 3 to the first element of IDj (step S1806). On the other hand, if a negative result is obtained in step S1805, the CPU 401 inputs an element v to a path DAG ID acquisition unit 428 described later, and acquires a path DAG IDj held by the element v (steps S1807 and S1808).

  After the above processing, the CPU 401 registers IDj as a path DAG ID in the DN (step S1809). Further, the CPU 401 inputs IDj to the path DAG ID registration unit 439 (step S1810). Thereafter, the CPU 401 adds 1 to the variable i and returns to step S1803 (step S1811).

[Pass DAG ID registration unit 439]
The processing contents of the path DAG ID registration unit 439 used in step S1810 described above will be described. FIG. 20 is a flowchart showing the processing contents of the CPU 401 functioning as the path DAG ID registration unit 439.

First, the CPU 401 receives a path DAG IDi (step S1901). Next, the CPU 401 sets the j-th element of IDi to i [j] (step S1902).
Here, the CPU 401 determines whether i [1] is 0 or 1 (step S1903). When i [1] is 0 or 1, the CPU 401 adds 0 to the end of the annotation element determination bit string 431 (step S1904), and adds i [2] to the end of the XML element depth number sequence 433 ( In step S1905), i [1] is added to the end of the text element determination bit string 432 (step S1906).

  Furthermore, the CPU 401 determines whether i [2] is 0 (step S1907). If i [2] is 0, the CPU 401 ends the registration process at this point. On the other hand, if i [2] is other than 0, the CPU 401 adds i [3] to the end of the i [2] -th number sequence in the depth-specific ID sequence list 434 and ends the registration process ( Step S1908).

  On the other hand, in the case of a negative result in step S1903, that is, when i [1] is 2 or 3, the CPU 401 adds 1 to the end of the annotation element determination bit string 431 (step S1910). Further, the CPU 401 adds i [2] to the end of the annotation element depth sequence 438 (step S1911).

  Thereafter, the CPU 401 determines whether i [1] is 2 (step S1912). When i [1] is 2, the CPU 401 adds 0 to the end of the annotation end tag determination bit string 435 and i [3] to the end of the annotation start tag ID string 436, and ends the registration process ( Steps S1913 and S1914).

  On the other hand, if a negative result is obtained in step S 1912, that is, if i [1] is 3, the CPU 401 adds 1 to the end of the annotation end tag determination bit string 435 and the annotation end tag ID string 437. I [3] is added to the end, and the registration process ends (steps S1915 and S1916).

[Overview of search operation]
Here, the search operation according to the present embodiment will be described. The search operation in this embodiment is executed by the CPU 401 functioning as the location path search unit 420. The CPU 401 follows the path DAG along the location path given by the search query, and acquires the path DAG ID of the path DAG element that matches the structure of the location path.

  The CPU 401 determines from the acquired path DAG ID whether the element that is the search result is an XML element or an annotation element. If the element that is the search result is an XML element, the CPU 401 functions as the XML element search unit 443 and calculates the position of the element in the numerical sequence data that matches the search query. On the other hand, when the element that is the search result is an annotation element, the CPU 401 functions as the annotation element search unit 444 and calculates the position of the element in the sequence data that matches the search query.

Here, the XML element search unit 443 and the annotation element search unit 444 perform operations called “rank”, “select”, and “nearest” on the sequence.
(1) rank (c, p): number of c in the element at the p-th position in the number sequence (2) select (c, n): position of c appearing n times in the number sequence (3) nearest ( p, d): position of the element closest to p having a value less than or equal to d in the element after the pth in the sequence

  Here, a series of processing operations will be described with reference to FIG. FIG. 16 shows an example of searching for an element matching the location path “/ e / c / d” using the path DAG 423 and the sequence data.

  First, the CPU 401 obtains a path DAG ID (0, 3, 3) by following the path DAG along the location path. In FIG. 16, the corresponding path DAG ID is surrounded by a broken line. Here, when the first element of the path DAG ID is “0”, it indicates an XML element, and the second element “3” indicates a depth.

  Therefore, the CPU 401 searches for a position including “3” that is the third element of the path DAG ID in the third number sequence (the number sequence at the position where the depth is “3”) in the depth-specific ID column list 434. In the case of FIG. 16, “3” is the fourth in the sequence of depth “3”. This element is also surrounded by a broken line in FIG.

  Next, the CPU 401 calculates select (3, 4) for the depth sequence 433 of the XML element, and obtains “14”, which is the position where “3” appears for the fourth time. Next, the CPU 401 calculates select (0, 14) for the annotation element determination bit string 431. This is because 0 is registered at the position of the XML element in the annotation element determination bit string 431. Therefore, this calculation means obtaining the position of the XML element that appears for the 14th time in the annotation element determination bit string 431. Here, “15” is obtained as the calculation result.

  As shown in the upper left part of FIG. 16, the element of the DOM DAG corresponding to “15” is “d” of the DOM DAG of the XML document 2. “15” indicates the position of the start tag in the element. The position of the end tag of the element can be obtained in the same way.

[Location path search unit 420]
FIG. 21 is a flowchart showing processing of the CPU 401 that functions as the location path search unit 420.

  The CPU 401 follows the path DAG 423 along the location path, and sets the path DAG ID corresponding to the reached element to i (step 2001). Next, the CPU 401 sets s as the first element of IDi and s as the second element (step S2002). Further, the CPU 401 sets 1 to the variable j (step S2003). Further, the CPU 401 sets L as an empty list for holding a pair of a start position and an end position of a search target tag (step S2004).

  Here, the CPU 401 determines whether the element s is 0 or 1 (step S2005). If the element s is 0 or 1, the CPU 401 inputs i and j to the XML element search unit 443, and obtains a tuple t of the obtained tag start position and end position (step S2006).

  Next, the CPU 401 determines whether or not the tuple t is (−1, −1) (step S2007). When the tuple t is not (−1, −1), the CPU 401 adds the tuple t to the tail of the list L and increments j by 1 (steps S2008 and S2009). Steps S2006 to S2009 are repeated until the tuple t becomes (−1, −1) (step S2007). The CPU 401 repeats steps S2006 to S2009 until the tuple t becomes (−1, −1). When the tuple t becomes (-1, -1), the CPU 401 outputs the list L and ends the search process (step S2014).

  On the other hand, if a negative result is obtained in step S2005 (in this case, the element s is neither 0 nor 1), the CPU 401 inputs i and j to the annotation element search unit 444, A tuple of the start position and end position of the obtained tag is set to t (step S2010).

  Here, the CPU 401 determines whether or not the tuple t is (−1, −1) (step S2011). Also in this case, when the tuple t is not (−1, −1), the CPU 401 adds the tuple t to the tail of the list L and adds 1 to the variable j (steps S2012 and S2013). The CPU 401 repeats steps S2010 to S2013 until the tuple t becomes (-1, -1). When the tuple t becomes (-1, -1), the CPU 401 outputs the list L and ends the search process (step S2014).

[XML element search unit 443]
FIG. 22 is a flowchart illustrating processing of the CPU 401 functioning as the XML element search unit 443.

  First, the CPU 401 sets the input path DAG ID as i and the search number as n (step S2101). Next, the CPU 201 sets d as the second element of the path DAG IDi and j as the third element (step S2102). Further, the CPU 401 sets m as the number of j included in the d-th number sequence in the depth-specific ID sequence list 434 (step S2103).

  Here, the CPU 401 determines whether m is smaller than n (step S2104). If m is less than n, the CPU 401 outputs a tuple (-1, -1) consisting of two elements and ends the search process (step S2105).

  On the other hand, if m is greater than or equal to n, the CPU 401 calculates select (j, n) for the d-th number sequence in the depth-specific ID sequence list 434 and sets the result to n (step) S2106).

  Next, the CPU 401 calculates select (d, n) for the depth sequence 433 of the XML element, and sets the result to n (step S2107).

  Further, the CPU 401 calculates select (0, n) for the annotation element determination bit string 431 and sets it to the variable s (step S2108).

  Next, the CPU 401 calculates nearest (n, d) for the depth sequence 433 of the XML element, and sets the result to a variable p (step S2109).

  Thereafter, the CPU 401 calculates select (0, p) for the annotation element determination bit string 431 and sets the result to p (step S2110).

  Next, the CPU 401 calculates rank (1, n) for the annotation element determination bit string 431 and sets the result in a variable r (step S2111).

  Further, the CPU 401 calculates nearest (r, d) for the depth sequence 438 of annotation elements, and sets the result to r (step S2112).

  Further, the CPU 401 calculates select (1, q) for the annotation element determination bit string 431 and sets it to the variable q (step S2113).

  Further, the CPU 401 sets the smaller one of p and q to the variable e (step S2114).

  Then, the CPU 401 outputs a tuple (s, e) of a pair of s and e (step S2115).

[Annotation element search unit 444]
FIG. 23 is a flowchart showing the processing of the CPU 401 functioning as the annotation element search unit 444.

  First, the CPU 401 sets the input path DAG ID as i and the search number as n (step S2201). Next, the CPU 401 sets j as the third element of i (step S2202). Also, the CPU 401 sets m as the number of j included in the annotation start tag ID column 436 (step S2203).

  Here, the CPU 401 determines whether m is smaller than n (step S2204). If m is smaller than n, the CPU 401 outputs a tuple (-1, -1) consisting of two elements and ends the search process (step S2205).

  On the other hand, if m is greater than or equal to n, the CPU 401 calculates select (j, n) for the annotation start tag ID string 436 and sets the result to m (step S2206).

  Next, the CPU 401 calculates select (0, m) for the annotation end tag determination bit string 435 and sets the result to m (step S2207).

  Further, the CPU 401 calculates select (1, m) for the annotation element determination bit string 431 and sets it to the variable s (step S2208).

  Further, the CPU 401 calculates select (j, n) for the annotation end tag ID column 437 and sets the result to m (step S2209).

  Thereafter, the CPU 401 calculates select (1, m) for the annotation end tag determination bit string 435, and sets the result to m (step S2210).

  Further, the CPU 401 calculates select (1, m) for the annotation element determination bit string 431 and sets it to the variable e (step S2211).

  Further, the CPU 401 outputs a tuple (s, e) of a pair of s and e (step S2212).

[Effect of Example]
In the structured document search apparatus 400 according to the present embodiment, a method of describing the structure of the DOM DAG using the path DAG and the numerical sequence data is adopted. In this case, the structured document search apparatus 400 does not need to hold the DOM DAG created from the annotation data corresponding to each XML document, and greatly reduces the memory capacity consumption compared to the above-described embodiment. be able to.

[Fifth embodiment]
A concise bit vector is known as a data structure that can calculate rank and select for a bit string depending on the calculation amount of a constant order. In addition, a wavelet tree is known as a data structure that can hold numeric sequence data in a compressed state and efficiently calculate rank and select in the compressed state.

  A wavelet tree is a data structure developed from a concise bit vector, and both require dictionary data for calculation in advance. As a method for constructing dictionary data and a method for calculating rank and select using the data structure, the method described in Non-Patent Document 2 may be used.

  In this embodiment, after the processing function as the search index construction unit 454 is executed, the simple bit vector / wavelet tree construction unit 455 performs the annotation end tag determination bit string 435, the text element determination bit string 432, the annotation by the known method described above. A concise bit vector is generated for the element determination bit string 431, and an XML element depth number string 433, a depth-specific ID string list 434, an annotation start tag ID string 436, an annotation end tag ID string 437, and an annotation element depth A wavelet tree is generated for the sequence 438.

[Effect of Example]
The structured document search apparatus 400 according to the present embodiment can improve the rank operation and the select operation in the XML element search unit 443 and the annotation element search unit 444 by using the prepared simple bit vector and wavelet tree. .

[Sixth embodiment]
In actual operation, it is desired that different annotation data can be added to or deleted from the same XML document. In the present embodiment, a method of adding an annotation element group without greatly changing the index configuration in a state where an index has already been constructed for a given XML document will be described.

  When an annotation element is added, the parent set of each element is changed. For this reason, an element that has been considered to be identical on the path DAG so far must be treated as another element. In addition, when an annotation is added, the text area is divided, so that not only the path DAG ID is changed, but also the number of elements representing the text area increases. Further, when an annotation is added, not only the structure of the path DAG is changed, but also a part of the number c in the number sequence data needs to be replaced with a number sequence consisting of a number and c that were not in the number sequence so far.

  In the following, when a part of the number c in the number sequence registered in the wavelet tree 446 is changed to a number sequence N consisting of numbers that were not in the number sequence so far, a data structure is added to the existing wavelet tree 446 An extended wavelet tree 445 that enables rank, select, and lookup at the time of change will be described.

[Extended wavelet tree 445]
FIG. 24 is a diagram showing an outline of the extended wavelet tree 445. The extended wavelet tree 445 includes a wavelet tree 446 composed of the original number sequence, a number change table 447 indicating which number the changed number x is registered in the original number sequence, and which part of the entire number sequence An addition flag 448 indicating whether a number has been added, a number-specific addition flag 449 indicating which position is added to each number in the original number sequence, and a number related to the change in the numbers constituting the original number sequence It consists of a corresponding modified wavelet 450.

[Extended wavelet tree construction unit 451]
FIG. 25 is a flowchart showing processing of the CPU 401 functioning as the extended wavelet tree construction unit 445. When the p-th number c registered in the wavelet tree 446 is changed to the number N, the CPU 401 expands the wavelet tree 446 according to the following procedure.

  First, the CPU 401 prepares a number sequence B that has the same length as the number sequence registered in the wavelet tree 446 and is initialized with all values being 0 (step S2401). Next, the CPU 401 sets the length of the list N to | N | and adds | N | −1 “1” s after the p-th in the sequence B (step S2402).

  Thereafter, the CPU 401 creates a simple bit vector of the sequence B and sets it as an addition flag 448 (step S2403). Next, the CPU 401 calculates rank (p, c) of the additional flag 448, and sets the calculation result to q (step S2404).

  Here, the CPU 401 sets m as the number of numbers c registered in the wavelet tree 446 (step S2405). Further, the CPU 401 prepares a sequence m of length m that is initialized with all values being 0, and adds | N | −1 “1” s after the q-th (step S2406).

  Thereafter, the CPU 401 creates a concise bit vector of the sequence V and sets it as a number-by-number addition flag 449 corresponding to the number c (step S2407). Further, the CPU 401 creates a wavelet tree that holds the sequence N, and sets this as a modified wavelet 450 corresponding to the number c (step S2408). After that, the CPU 401 creates a number change table 447 that describes which numbers constituting the changed number sequence correspond to the numbers constituting the original number sequence (step S2409).

[Rank calculation unit 452 in the extended wavelet tree]
FIG. 26 is a flowchart showing processing of the CPU 401 functioning as a rank calculation unit 452 that executes rank calculation on the extended wavelet tree 445.

  First, the CPU 401 calculates rank (0, p) for the additional flag 448 and sets it to q (step S2501). Next, the CPU 401 acquires the number in the original number sequence of c from the number change table 447 and sets it as d (step S2502). Next, the CPU 401 calculates rank (c, q) for the original wavelet tree 446, and sets the calculation result to r (step S2503).

  Here, the CPU 401 determines whether c and d are the same (step S2504). If c and d are not the same, the CPU 401 outputs r and ends the arithmetic processing (step S2508).

  On the other hand, when c and d are the same, the CPU 401 calculates select (0, q) for the additional flag 448 and sets the calculation result to s (step S2505). Next, the CPU 401 calculates select (0, r) for the numerical addition flag 449 corresponding to d, and sets the calculation result to t (step S2506). Further, the CPU 401 calculates rank (c, t + ps) with respect to the numerical addition flag 449 corresponding to d, outputs the calculation result, and ends the arithmetic processing (step S2507).

[Select Calculation Unit 453 in Extended Wavelet Tree]
FIG. 27 is a flowchart illustrating the processing of the CPU 401 functioning as the select calculation unit 453 that executes the select calculation for the extended wavelet tree 445.

  First, the CPU 401 acquires the number in the original number sequence of c from the number change table 447 and sets it as d (step S2601).

  Here, the CPU 401 determines whether c and d are different (step S2602). When c is different from d (positive result), the CPU 401 calculates select (c, n) for the additional wavelet tree corresponding to d, and sets the calculation result to s (step S2603). Further, the CPU 401 calculates rank (0, s) for the numerical addition flag 449 corresponding to d, and sets the calculation result to n (step S2604).

  After this step S2604 or after obtaining a negative result in step S2602, the CPU 401 calculates select (0, n) for the numerical addition flag 449 corresponding to d and sets the calculation result to t ( Step S2606).

  Next, the CPU 401 calculates select (d, n) for the original wavelet tree 446 and sets the calculation result to m (step S2607). Further, the CPU 401 calculates select (0, m) for the addition flag 448 and sets the calculation result to u (step S2608).

  Here, the CPU 401 determines whether c and d are the same (step S2609). When c and d are the same, the CPU 401 outputs u and ends the calculation process (step S2610). On the other hand, if c and d are different, the CPU 401 outputs s−t + u as the calculation result, and ends the calculation process (step S2611).

[Effect of Example]
According to the structured document search apparatus 400 according to the present embodiment, different annotation data can be added to or deleted from the same XML document.

[Other examples]
The present invention is not limited to the above-described embodiments, and includes various modifications. For example, the above-described embodiments have been described in detail for easy understanding of the present invention, and are not necessarily limited to the case where all the configurations described are provided.

  In addition, a part of the configuration of a certain embodiment can be replaced with the configuration of another embodiment. It is also possible to add the configuration of another embodiment to the configuration of one embodiment. Further, with respect to a part of the configuration of each embodiment, another configuration can be added, deleted, or replaced.

  Each of the above-described configurations, functions, processing units, processing means, and the like may be realized by hardware by designing a part or all of them with, for example, an integrated circuit. Further, each of the above-described configurations, functions, and the like may be realized by software by the CPU interpreting and executing a program that realizes each function.

  Information such as programs, tables, and files for realizing each function can be stored in a recording device such as a memory, a hard disk, an SSD (Solid State Drive), or a recording medium such as an IC card, an SD card, or a DVD.

  Further, the control lines and information lines indicate what is considered necessary for the explanation, and not all the control lines and information lines on the product are necessarily shown. Actually, it may be considered that almost all the components are connected to each other.

400 Structured Document Retrieval Device 401 CPU (Central Processing Unit)
402 Main storage device 403A Auxiliary storage device 403B External storage device 404 Removable media 405 Network 406 Interface unit 407 XML document set 408 Annotation data set 409 DOM tree construction unit (for XML document)
410 DOM tree construction department (for annotation data)
411 Document structure list construction unit 412 Document structure list 413 Text element list 414 Text data list 415 Text sharing DOM tree construction unit 416 Text sharing DOM tree 417 Text data / text element list construction unit 418 Text allocation unit 419 Parent-child relationship analysis / registration unit 420 Location Path Search Unit 421 DOM DAG
422 DOM DAG construction part 423 path DAG
424 Transposition index construction unit 425 Transposition index 426 DOM DAG element list sort unit 427 Depth allocation unit 428 Path DAG ID acquisition unit 429 Path DAG element generation / registration unit 430 Search index 431 Annotation element discrimination bit string 432 Text element discrimination bit string 433 XML element Depth number sequence 434 Depth ID sequence list 435 Annotation end tag discrimination bit sequence 436 Annotation start tag ID sequence 437 Annotation end tag ID sequence 438 Annotation element depth number sequence 439 Path DAG ID registration unit 440 Search index registration unit 441 End of annotation Tag insertion unit 442 Transposed index registration unit 443 XML element search unit 444 Annotation element search unit 445 Extended wavelet tree 446 Consists of original sequence Wavelet tree 447 Number change table 448 Additional flag 449 Number-specific addition flag 450 Changed wavelet tree 451 Extended wavelet tree construction unit 452 Rank calculation unit 453 in extended wavelet tree Select calculation unit 454 in extended wavelet tree Search index construction unit 455 Simple bit vector・ Wavelet tree construction department

Claims (12)

A processor for executing the program;
A first storage area for storing a program;
A second storage area for storing a structured document satisfying the tree structure condition and annotation data attached to the document;
By assigning the text of the structured document to the structure in which the root element of the DOM (Document Object Model) tree obtained individually from the inclusion relation of the tags of the structured document and the inclusion relation of the tags of the annotation data is assigned, the text A document structure list construction unit for generating a shared DOM tree;
An input device for entering a search query;
A structured document search apparatus comprising: a location path search unit that searches the text sharing DOM tree for an element that matches a location path given as the search query. A processor for executing the program;
A first storage area for storing a program;
A second storage area for storing a structured document satisfying the tree structure condition and annotation data attached to the document;
Inclusion relationship between tags of different DOM trees with respect to a structure in which a root element of a DOM (Document Object Model) tree obtained individually from the inclusion relationship of tags of the structured document and the inclusion relationship of tags of the annotation data is shared A document structure list construction unit that generates a DOM DAG (Directed Acyclic Graph) by assigning the text of the structured document to the structure after incorporation,
An input device for entering a search query;
A structured document search apparatus comprising: a location path search unit that searches the DOM DAG for an element that matches a location path given as the search query. The structured document search device according to claim 2,
A path DAG element generation / registration unit that generates a path DAG in which the structures of the plurality of DOM DAGs are aggregated;
A transposition index construction unit that constructs a transposition index composed of a path DAG ID that is an ID of the element of the path DAG and position information of one or more elements of the DOM DAG that are in a correspondence relationship;
The said location path search part calculates the location where the element which corresponds to the location path which is a search query appears based on the said path | pass DAG and the said transposition index. The structured document search apparatus characterized by the above-mentioned. The structured document search device according to claim 2,
A path DAG element generation / registration unit that generates a path DAG in which the structures of the plurality of DOM DAGs are aggregated;
A search index construction unit that constructs a search index that holds the path DAG, a bit string, and numerical sequence data that stores a type of location path corresponding to each element of the DOM DAG;
The location path search unit calculates a path DAG ID corresponding to a location path that is a search query from the path DAG, and a location where an element specified by the path DAG ID obtained by the calculation appears is the bit string and the A structured document search apparatus characterized by performing calculation by scanning numerical sequence data. The structured document search device according to claim 2,
A path DAG element generation / registration unit that generates a path DAG in which the structures of the plurality of DOM DAGs are aggregated;
A search index construction unit that constructs a search index that holds the path DAG, a bit string, and numeric data that stores a type of location path corresponding to each element of the DOM DAG;
A concise bit vector / wavelet tree generation unit for generating a concise bit vector and a wavelet tree based on the bit string and the sequence data held by the search index;
The location path search unit calculates a path DAG ID corresponding to a location path which is a search query from the path DAG, and a location where an element specified by the path DAG ID obtained by the calculation appears is the concise bit vector. Alternatively, the structured document search apparatus, wherein the calculation is performed by a rank operation and a select operation on the wavelet tree. The structured document search apparatus according to claim 5,
When a part of a number sequence registered in the wavelet tree is replaced with another number sequence by adding annotation data, the wavelet tree is converted into an extended wavelet tree including change information for the wavelet tree. Has an extended wavelet tree construction department,
The location path search unit uses the extended wavelet tree for the rank operation and the select operation. For a structure in which the root element of a DOM (Document Object Model) tree obtained individually from the inclusion relation of tags of structured documents that satisfy the tree structure condition and the inclusion relation of tags of annotation data attached to the document is shared, A first process of assigning text of a structured document and generating a text sharing DOM tree;
A program that causes a computer to execute a second process of searching an element that matches a location path given as a search query from the text sharing DOM tree. For a structure in which the root element of a DOM (Document Object Model) tree obtained individually from the inclusion relation of tags of structured documents that satisfy the tree structure condition and the inclusion relation of tags of annotation data attached to the document is shared, A first process of incorporating a containment relationship between tags of different DOM trees, and assigning a text of a structured document to the structure after the incorporation, and generating a DOM DAG (Directed Acyclic Graph);
A program that causes a computer to execute a second process of searching the DOM DAG for an element that matches a location path given as a search query. The program according to claim 8 is a process executed by a computer.
A third process for generating a path DAG in which the structures of the plurality of DOM DAGs are aggregated;
A fourth process for constructing a transposed index composed of a path DAG ID that is an ID of the element of the path DAG and position information of one or more elements of the DOM DAG that are in a corresponding relationship; ,
The program according to the second aspect is characterized in that, based on the path DAG and the transposed index, a portion where an element that matches a location path that is a search query appears is calculated. The program according to claim 8 is a process executed by a computer.
A third process for generating a path DAG in which the structures of the plurality of DOM DAGs are aggregated;
A fifth process for constructing a search index that holds the path DAG, a bit string, and numerical sequence data that stores a type of location path corresponding to each element of the DOM DAG;
In the second process, a path DAG ID corresponding to a location path that is a search query is calculated from the path DAG, and a place where an element specified by the path DAG ID obtained by the calculation appears is the bit string and the A program characterized by being calculated by scanning numerical data. The program according to claim 8 is a process executed by a computer.
A third process for generating a path DAG in which the structures of the plurality of DOM DAGs are aggregated;
A fifth process for constructing a search index that holds the path DAG, a bit string, and numerical sequence data that stores a type of location path corresponding to each element of the DOM DAG;
A sixth process for generating a concise bit vector and a wavelet tree based on the bit string and the number sequence data held by the search index;
In the second process, a path DAG ID corresponding to a location path that is a search query is calculated from the path DAG, and a place where an element specified by the path DAG ID obtained by the calculation appears is the concise bit vector. Alternatively, the program is calculated by a rank operation and a select operation on the wavelet tree. The program according to claim 11 is a process to be executed by a computer.
When a part of a number sequence registered in the wavelet tree is replaced with another number sequence by adding annotation data, the wavelet tree is converted into an extended wavelet tree including change information for the wavelet tree. Having a seventh process,
In the program, the second process uses the extended wavelet tree for the rank operation and the select operation.

Images