KR100558765B1 - Method for executing xml query using adaptive path index - Google Patents

Abstract

The present invention relates to an XML query processing method using an adaptive path index that can dramatically improve the search speed of XML data by using a search pattern frequently used for XML data and can reduce storage space compared to an existing index. A first step of representing the XML data in an XML graph in the form of a graph; A second step of generating and updating an adaptive path index from the graph and frequently used paths extracted from previously performed XML queries; A third step of processing an XML query using the adaptive path index; and providing an XML query execution method using the adaptive path index, wherein the adaptive path index is used when retrieving XML data. By using frequently used paths, XML query results can be found more efficiently. When the pattern of XML queries is changed, this can reduce the burden of updating the index.

XML, Adaptive Path Index, Hash Tree, Extents, IDREF

Description

How to execute WLML query using adaptive path index {METHOD FOR EXECUTING XML QUERY USING ADAPTIVE PATH INDEX}

1 is a diagram illustrating a management structure of an adaptive path index according to the present invention;

2 is a diagram illustrating XML data;

3 is a diagram representing a structure of XML data;

4 illustrates an adaptive path index;

5 illustrates a hash table structure in a hash tree for an adaptive path index;

6 illustrates an initial adaptive path index generation algorithm;

7 illustrates an initial adaptive path index;

8 is a diagram illustrating a path extraction algorithm that is frequently used;

9 is a diagram illustrating an update algorithm of an adaptive path index;

10 is a graph showing the performance of a single path expression over Play data,

11 is a graph showing the performance of single path expressions for FlixML data,

12 is a graph illustrating the performance of single path expressions for GedML data,

13 is a graph comparing and comparing the performance of a complex path query;

14 is a graph comparing the performance of a value-path mixed query.

The present invention relates to XML (Extensible Markup Language, T. Bray, J. Paoli, CM Sperberg-McQueen, and E. Maler. Extensible markup language (xml) 1.0 (second edition) , which is a standard for data representation and exchange on the Internet . W3C ) is an index structure and index management method that can efficiently search the data represented by W3C ) . In particular, it is possible to dramatically improve the speed of XML data search by using a search pattern that is frequently used for XML data. The present invention relates to an XML query processing method using an adaptive path index that can reduce storage space.

The advent of the Internet has led to a dramatic increase in the variety of information in electronic form. XML was introduced by the W3C in 1998 as a way to overcome the limitations of existing HTML on the Internet and solve the complexity of SGML. XML can represent a variety of types of data, from regular structures to irregular structures, to deeply nested structures. Because of its flexibility, XML is emerging as the standard language for data representation and exchange on the next generation of the Web.

Various query languages have been proposed for retrieving information expressed in XML. XPath [Reference: J. Clark and S. DeRose. XML path language (XPath) version 1.0. W3C] and XQuery [References: S. Boag, D. Chamberlin, M. Fernandez, D. Florescu, J. Robie, J. Simeon, and M. Stefanescu. XQuery 1.0: An XML query language. W3C], such as XML query languages, use a path expression to search for an unstructured structure of XML elements. Therefore, exploring XML data of atypical structure according to given path expression is an important factor for processing XML query. However, the elements that make up the XML data may be distributed elsewhere on disk, so the performance of XML query processing is very poor. Moreover, in order to process an XML query consisting of partial matching path expressions, all elements belonging to the XML data must be retrieved, which is very inefficient.

A structural summary or path index, on the other hand, speeds up the retrieval of XML data by allowing only relevant portions of the XML data to be retrieved for a given path expression. Therefore, a method of extracting structure summaries and generating path indexes for improving the retrieval speed of XML data has recently received a lot of attention, and various indexes have been proposed for improving the retrieval performance of unstructured data.

Goldman and Widom developed a route index called strong DataGuide [Ref. R. Goldman and J. Widom. Data Guides: Enable query formulation and optimization in semistructured databases. VLDB 1997.] . This method is proposed as a method for extracting structural information of semi-structured data such as XML, and expresses simple paths starting from the root element of XML data so that they do not overlap. The generation method of DataGuide is an algorithm for converting non-deterministic finite automata into deterministic finite automata. [Reference: JE Hopcraft and JD Ullman. Introduction to Automata Theory, Language, and Computation. 1979] . Therefore, there is a problem that the size of the strong DataGuide may be larger than the original XML data when the given XML data has a very complicated graph structure.

Milo and Suciu proposed a different 1-index than DataGuide [Ref. T. Milo and D. Suciu. Index structures for path expression. ICDT. 1999] . 1-Index is the same as strong DataGuide in that it keeps information of all paths starting from the root element. 1-Index generates an index using backward simulation and backward bisimulation based on graph theory. This method combines two nodes into one node if the set of paths from each node is the same when there are two nodes on the graph. In this way, unlike a strong DataGuide, you get a graph like a non-deterministic finite automata. However, if the input graph is tree, 1-Index and strong DataGuide are the same. Thus, 1-Index can be seen as a nondeterministic variant of the strong DataGuide.

In the field of object-oriented databases, access support relations (ASRs) have been used to support frequently used references between any two objects [Ref. A. Kemper and G. Moerkotte. Access support relations: An indexing method for object bases. Information Systems, 17 (2): 117-145, 1992] . However, this access support relationship has a problem in that it can support only partial paths which are predefined as materializing reference chains of arbitrary queries.

Cooper et al. Have proposed an Index Fabric that is conceptually similar to a strong DataGuide in that it maintains all paths beginning with the root element [References: B. Cooper, N. Sample, MJ Franklin, GR Hjaltason, and M. Shadmon. A fast index for semistructured data. VLDB. 2001] . Index Fabric encodes the paths of elements with data values as strings and converts them into strings, and maintains them using string indexes such as Patricia Trie. However, there is a disadvantage that Index Fabric cannot maintain parent-child relationship between XML elements. Therefore, Index Fabric is not effective for partial matching path expressions that require the use of parent-child relationships.

The user of the XML data does not consider the structure of the data and intentionally uses partial matching path expressions to achieve the desired result. However, the XML path indexes mentioned above, such as the strong DataGuide, 1-Index, and Index Fabric, represent all paths starting from the root element, which leads to performance degradation by exhaustively searching the index to process partial matching path expressions. do. Moreover, since these path indexes are created using only data, they do not utilize a query workload, which is a set of past query information for effectively processing frequently used path expressions.

In order to solve the above problems, the present invention has developed an adaptive path index called APEX (Adaptive Path indEx for XML Data). An object of the present invention is a method for processing a query of XML data having an unstructured structure by using a path index, which extracts frequently used paths from path expressions used in the past as a query of XML data and uses the path index. The present invention provides an XML query processing method using an adaptive path index method that improves the query performance by updating the.

According to an aspect of the present invention, there is provided a method of performing an XML query using a path index to perform a query on XML data, the method comprising: a first step of representing the XML data in a graph-type XML graph; Creating and updating an adaptive path index from the graph and frequently used paths extracted from previously performed XML queries; A third step of processing an XML query using the adaptive path index provides a method for performing an XML query using an adaptive path index.

Unlike the existing path indexes such as DataGuide and 1-Index, the adaptive path index proposed in the present invention does not maintain all paths starting from the root element and uses frequently used paths to improve query performance. Furthermore, while existing path indexes are generated using only XML data, the present invention identifies and utilizes paths that are frequently used by queries used in the past by using data mining concepts.

Specifically, the adaptive path index and query processing method according to the present invention is characterized by a method having the following solution.

(1) The adaptive path index is composed of a hash tree and a graph structure. Since the hash tree maintains information on the arrival paths of nodes in the graph structure, the adaptive path index is used to generate a partial matching path expression. This can be done efficiently by searching the hash tree.

(2) The concept used in the sequential pattern mining technique is used to extract frequently used path information.

(3) By using the frequently used paths, the index structure is maintained to achieve a smaller size than the existing path indexes.

(4) The adaptive path index reduces the burden of creating and managing indexes by changing the index by identifying only the changed paths when frequently used paths are changed.

The above object and various advantages of the present invention will become more apparent from the preferred embodiments of the present invention described below with reference to the accompanying drawings by those skilled in the art. Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 illustrates a management structure of an adaptive path index according to the present invention. As shown in FIG. 1, the adaptive path index management module is largely divided into an initialization module 11, a frequently used path extraction module 13, and an update module 15. It consists of three main modules. The initialization module 11 is a module used when generating an adaptive path index for the first time without query information used in the past. This module creates the initial adaptive path index APEX ⁰ (12), which is the initial index of the adaptive path index. APEX ⁰ is the simplest form of adaptive path index and serves as the seed for complex adaptive index creation. The path extraction module 13 and the update module 15 are modules that use a query workload (14), which is a set of queries using the current path index. Used to generate. At this time, the query load 14 is l _i . L _{i + 1} ... l _j-1 .l _j is a set of single path expressions. The path extraction module 13 and the update module 15 are repeated each time the query load changes.

First, the structure of the XML data used in the present invention will be briefly described, and based on this, the structure of the adaptive path index proposed by the present invention will be described. Next, the above-described adaptive path index management method will be described.

FIG. 2 illustrates an example of XML data, and its structure may be represented by a label-edge graph as shown in FIG. 3. This is called an XML graph. In this case, the ID-IDREF relationship shown in FIG. 3 is expressed as an edge from a node of an IDREF type to a node representing an element having an attribute of a corresponding ID type. The label of this edge has the label of that element. In addition, edge labels that point to nodes for elements of type IDREF begin with an "@".

In the XML graph, there are paths consisting of a series of labels, which are used as path expressions in the XML query. The following relationship may exist between each path. First, if any two paths A and B have a relationship as in Definition 1 below, it is said that "path B includes path A".

Definition 1

Path A = a ₁ .a ₂ ... .a _n and B = b ₁ .b ₂ ... for .b _m , if a ₁ = b _i , a ₂ = b _i +1,. When a _n = b _{i + n-1} and 1 ≦ i and i + n-1 ≦ m, “path A is included in path B” or A is a subpath of B. Furthermore, if A is a subpath of B and m = i + n-1, then A is called the suffix of B.

In addition, how often any path p on the XML graph is used among the given XML path expressions is referred to as the support (p), sup (p) of p, and is expressed as Equation (1).

sup (p) = | Q | / | W |

Where | W | = Number of XML path expressions given, | Q | The number of XML path expressions, including = p.

In the adaptive path index management method according to the present invention, the required paths defined in the following Definition 2 are identified and the paths are managed using the required paths.

Definition 2

When a support sup of the path p present in the XML graph, sup (p) is greater than a user specified minimum support, minSup, or the length of p is 1, p is called a required path. In particular, a path having a support greater than the user-defined minimum support minSup is called a frequently used path.

Edge set T (p) for arbitrary path p is defined as

Definition 3

p = l _i ... .l _{j-1 When} .l _j , T (p) = {<o _j-1 , o _j > | o _i-1 .l _i .o _i . .l _j-1 .o _j-1 .l _j .o _j }

Here, _k l with respect to the label may appear on p o _{k-1, k} o is the label of a node that exists in the XML deulyigo graph in o _k-1 to _k l _k o trunk exists in the XML graph.

From definition 3, it can be seen that for arbitrary paths p and q, if p is the suffix of q, then T (p) ⊇ T (q). For example, in the graph of FIG. 3, the path name is a suffix of actor.name. Where T (name) = {<2,3>, <4,5>, <7,11>, <12,13>}, and T (actor.name) = {<2,3>, <4, 5>}. Thus, T (name) ⊇ T (actor.name) is shown. Managing the trunk set T (p) for all paths belonging to the set of required paths requires a lot of storage burden. Therefore, in the present invention, the extent (extent), E (p) of the path p is defined and managed as follows.

Definition 4

The set of paths starting from the root of the XML graph path is called Q _XML and the set of necessary paths is called R. For path p in set R, Q _G (p) = {l | l l Q _XML and p is a suffix of l}, Q _A (p) = {l | l ∈ Q _XML and every path q (≠ p) Let's say R having p as a suffix is suffix of l}. If Q (p) = Q _G (p) -Q _A (p), then the extent E (p) = ∪ _{r∈Q (p)} T (r) is defined.

In definition 4, q for any path p is a path having p as a suffix among the paths belonging to R, and it can be seen that T (p) = = _∀q E (q).

For example, for the XML graph of FIG. 3, when actor.name is a frequently used path, E (name) = {<7,11>, <12,13>} and E (actor.name) = {<2,3>, <4,5>} and T (name) = E (name) ∪ E (actor.name).

4 shows an adaptive path index when all paths having a length of 1 and direct.movie, @ movie.movie, and actor.name are required for FIG. This shows the index of the graph structure, and may further include a hash tree for more efficient searching.

The hash tree maintains information about the required paths and maps each node of the graph structure to the required paths. Each node of the hash tree has a hash table, and the structure of each entry of the hash table consists of five fields as detailed in FIG. 5: label, count, new, xnode, and next are each This is the key value for the entry. count represents the frequency of use, or support, of the path represented by the entry. The new field indicates whether the entry is new or not. xnode points to a node in the graph structure of the adaptive path index. Finally, the next field points to another node of the hash tree.

The graph structure provides structure summary information for a given XML graph. Each node in the graph structure has a one-to-one correspondence with an entry in the hash tree, and the nodes in the graph structure have the extent of the required path represented by the hash tree entry. Also, for edges <s _x , t _x > belonging to any two nodes x, y and extents of the graph structure, and edges <s _y , t _y > belonging to extents _y , if t _x = s _y Make sure there is an edge from node x to y in the graph structure. In addition, the label of the edge uses the label which classified the edge which belongs to y. Also, especially for the root node of the XML graph, one node is created at the initial adaptive path index, and a virtual edge composed of <null, root node> is stored as an extent of the node. And that node is conveniently represented as xroot. Also, if a path q with a p as a suffix for an arbitrary path p is a frequently used path and E (p) is not empty, for this purpose, a remainder entry is created and a corresponding node is created by E (p). Manage. For example, in FIG. 4, E (name) is stored at node & 12, which is registered in the remainder entry in the subnode of the name entry of the root node of the hash tree.

Information about the path direct.movie required in FIG. 4 can be grasped by looking up the hash tree in the reverse direction. For example, you can search for direct.movie by searching direct for the subnode pointed to by the movie entry in the root node of the hash tree.

6 illustrates an algorithm for generating APEX ⁰ , which is an initial adaptive path index. FIG. 7 shows APEX ⁰ for FIG. 3. As mentioned above, the adaptive path index consists of a hash tree and a graph structure. Therefore, APEX ⁰ is composed of this structure.

The APEX ⁰ generation algorithm of FIG. 6 basically creates extents by grouping edges according to each label while searching nodes in an XML graph in a depth first traversal manner, and graphing nodes for the same. Creates a structure and registers it with the hash tree. First, a node for each set of edges is created at the initial adaptive path index and the node and label are registered in the hash tree. After generating APEX ⁰ , the adaptive path index is continuously updated by extracting frequently used path information from the query load. This allows for more efficient support of XML queries currently in use.

The following describes the frequently used path extraction module.

Sequential pattern mining techniques using anti-monotonicity characteristics in the pruning step [Ref. MN Garofalakis, R. Rastogi, and K. Shim. SPIRIT: Sequential patternmining with regular expression constraints. VLDB 1999] can be used to extract frequently used path indexes. However, modification is necessary because the characteristics of the sequence, which is the target of the existing sequential pattern mining techniques, are different from the path. For example, if the sequence (A, B, C) appears frequently, the subsequences (A, B), (B, C), (A, C) of (A, B, C) also appear frequently. can do. However, just because the path ABC is used frequently does not mean that AC is used often. Because AC is not a subpath of ABC.

Therefore, in the present invention, as shown in FIG. 8, a newly used path extraction algorithm is newly developed. As shown in FIG. 8, a frequently used path extraction algorithm is composed of a part for calculating a support and a battery part. The hash tree is used to maintain a change in the usage pattern of XML queries. After the extraction phase of the frequently used path is finished, the hash tree maintains only information on the required paths among the given XML path expressions.

First, to calculate the frequency of use (local map), we use the hash tree, which is an important data structure that constructs the adaptive path index, to extract the frequency of use of all paths in the set of path expressions. At this time, the count and new fields of all entries in the hash tree are set to 0 and false to calculate the frequency of use of the currently used XML path expressions. It then calculates the frequency of use for all paths that appear in Q _workload , a given set of XML path expressions. In this step, if a new entry is created in the hash table, set the new field of the entry to true.

The cell phase removes all entries with a given user-defined minimum support, less than minSup. In this case, such as sequential pattern mining, if sup (p) of random path p is smaller than minSup, sup (p) of all paths including p is smaller than minSup, so that it is less frequently used. Remove path information from the hash tree.

After extracting the information about the frequently used paths from the given path expression, it is necessary to update the current adaptive path index. To do this, the XML graph can be exhaustively searched from the beginning to create a new adaptive path index. However, since this method is a time-consuming and costly operation, the index update cost is reduced by using the update algorithm of FIG. The basic approach of this update algorithm is to search the graph structure of the adaptive path index and check that each node of the graph structure is valid in relation to the hash tree, remove invalid nodes and generate nodes for the new entries. Then create an extent for each new node.

XML query processing using the adaptive path index according to the present invention is as follows. Arbitrary path p ⁱ _n = l _i ... .l _{n-1 When} .l _n is given in a query, p ⁱ _n is used to search the hash tree. If p ^k _n = l _k . _{l n (i <k ≤ n} ) of the path only if it exists in the hash tree, a set of p ^k _n by using this, the trunk T (p ^k _n) to obtain, such a step p subpath p ⁱ _j = l _i. ... Repeat when information of .l _j (i ≦ j <n) exists on the hash tree, that is, until T (p ⁱ _j ) is found. And the obtained trunk set T (p ⁱ _j ),... A T (p ⁱ _n ) can be obtained by performing a join operation on, T (p ^k _n ).

In addition, complex path queries such as l _i . *. L _j are also known as query cells and transformation techniques [MF Fernandez and D. Suciu. Optimizing regular path expressions using graph schemas. ICDE. 1998] by applying l _i . _{i + 1} ... After converting to a .l _j- type path set, you can get the query result. For a value-path mixed query such as "Extract nodes satisfying any condition among nodes satisfying an arbitrary path expression", extract nodes satisfying an arbitrary path using the adaptive path index according to the present invention. And then check whether the condition is satisfied, or find the intersection of two node sets after finding the nodes satisfying the arbitrary condition among the nodes in the XML data and the nodes satisfying the arbitrary path expression. This can be obtained using various methods.

If p ⁱ _n is a required path, there is a path q in the hash tree with p ⁱ _n as a suffix, and the extents E (q) of nodes of the graph structure pointed to by the node pointer of the entry corresponding to each q. T (p ⁱ _n ) = ∪ _∀q E (q)

In order to measure the effectiveness of the present invention for XML queries, various types of XML queries and various XML data were tested. As the experimental data, three XML data generated by using the actual XML data and the actual DTD defining the structure of the XML data were used.

(1) Play: An XML document created by converting Shakespeare plays to XML. [Source: http://www.oasis-open.org/cover/xml.html] .

(2) FlixML: An XML document used for commentary documents for class B movie guides. It has a slightly complex structure [Source: http://www.xml.com] .

(3) GedML: An XML document that represents data used in genealogy and has a very complex structure [Source: http://www.oasis-open.org/cover/xml.html, 2001] .

In addition, to measure the query performance of various sizes of XML data, data with various numbers of elements is generated as shown in Table 1.

Data type Play                                              FlixML                                              GedML                                               name four_tragedy.xml shakes_11.xml shakes_all.xml Flix01.xml Flix02.xml Flix03.xml Ged01.xml Ged02.xml Ged03.xml The number of elements 22791 48818 179691 14734 41691 335401 8259 36228 381046

The query uses l _i .l _{i + 1.} … 5000 single continuous path of the label, such as _n .l expression (single label path expression) and 500 l _i. *. l _j form the compound path expression, and the value is expressed as the choice of the path 1000 and the expression value Path expressions were used. // l _i ./l _{i +} 1 /… in XQuery, the XML query standard for single-path expressions / l _n , the compound path expression is represented by // l _i // l _j , and the value-path expression is // l _i / l _{i + 1} /… / l _j [text () = value] In addition, we compared the efficiency of the present invention with DataGuide (SDG), IndexFabic and the initial adaptive path index (APEX0). In addition, since the shape of the adaptive path index may vary according to the user-defined support minSup, the experiment was also performed by changing the value of minSup from 0.002 to 0.05. As an XML data query set for extracting a frequently used path, Used 20% of single-path expressions.

10, 11, and 12 show processing times for 5000 single path expressions, while FIGS. 13 and 14 show complex path expressions and value-path expressions for shake_11, xml, Flix02, xml and Ged02.xml, respectively. Show processing time for. In FIG. 12, the SDG performance of Ged03.xml is 125000 seconds, and in FIG. 13, the performance of APEX0 of Ged02.xml is about 210000 seconds.

The more complex the XML data structure, the better the performance of the adaptive path index. DataGuide and Index Fabric maintain all the paths starting from the root of the XML data because the complexity of the XML data increases the number of these paths and thus the amount of information to be retrieved during query processing. to be. On the other hand, the adaptive path index keeps the information about frequently used paths so that the query can be processed more efficiently.

In addition, user-defined minimum support minSup also affects query processing performance. As minSup becomes smaller, the number of frequently used routes increases. However, as shown in FIGS. 10 to 12, increasing the number of frequently used paths does not always improve query processing performance. This is because, as mentioned above, as the structure of the path index becomes more complicated, the area to be searched increases, which may degrade performance. In this experiment, on the average, the adaptive path index with minSup of 0.005 showed the best performance.

Those skilled in the art will appreciate that various changes and modifications can be made without departing from the spirit of the present invention.

As described above, according to the present invention, an XML query result can be found more efficiently by utilizing paths frequently used by using an adaptive path index when searching XML data. In addition, the present invention proposes a method of reducing the burden of updating the index by reflecting this when the pattern of the XML query changes. Therefore, the present invention will greatly contribute to XML data application fields such as e-commerce and Internet document retrieval.

Claims (7)

Initialization module that is used to create an adaptive path index for the first time without query information used in the past and generates an initial adaptive path index (APEX0) 12 which is an initial index of the adaptive path index. module: 11 and a module using query workload 14, which is a set of queries using the current path index, are used to generate a more efficient path index 16 using the paths that are frequently used. A frequently used path extraction module (13) that extracts frequently used paths above a user-defined minimum support from the query load, which is a set of path expressions for XML queries, and the frequently used paths. Update mode for updating the initial adaptive path index by the adaptive path index update algorithm to include only In the adaptive path index management module including an update module 15 and stored in a web application server that stores and manages XML data, performing an XML query using a path index to perform a query on the XML data. In the method, The XML data is represented by a label-edge graph, which is a graph-type data structure, and there are paths formed by a series of labels. An XML graph used as a path expression of an XML query is expressed on a display part of a computer. A first step of making; From the browser to the web application server that stores and manages the XML data through the frequently used paths extracted from XML queries previously performed and the adaptive path index (APEX0) 12 from the XML graph. A second step of creating and updating; And A third step of processing an XML query using the adaptive path index (APEX0) 12 and displaying the result on a display of the computer; and a method of performing an XML query using an adaptive path index. . The method of claim 1, In the first step, a relationship between an ID of XML data and an attribute of IDREF type is defined as an edge from a node of IDREF type to a node representing an element having an attribute of corresponding ID type. Expressing a label of the edge, and having a label of the element, and displaying a label of an edge indicating a node of an IDREF type to be distinguished from a label of another edge to generate the XML graph. An XML Query Execution Method Using Adaptive Path Indexes. The method of claim 1, In the second step, an initial adaptive path index (APEX0) 12 representing the structure summary information of the XML graph is generated by the initialization module 11 of the adaptive path index management module, and the Internet network in the browser is generated. Extract the frequently used paths by the frequently used path extraction module 11 above the user defined minimum support from the query load which is the path expression set of the XML queries previously performed to the web application server storing and managing the XML data through Generate an adaptive path index by updating the initial adaptive path index to include only the frequently used paths by the update module 15, and reflect the change in the query load. XM using adaptive path index, characterized by continuously updating the adaptive path index L How to Perform a Query. The method of claim 2, In the second step, an initial adaptive path index representing the structure summary information of the XML graph is generated by the initialization module 11 of the adaptive path index management module, and the XML data is stored in a browser through an internet network. Extract the frequently used paths by the frequently used path extraction module 11 above the user defined minimum support from the query load 14, which is a path expression set of XML queries previously performed with the managing web application server, and update the update. Create an adaptive path index by updating the initial adaptive path index to include only the frequently used paths by module 15, and adapt the adaptive path index to reflect a change in the query load. Number of XML queries using adaptive path indexes Way. The method according to any one of claims 1 to 4, The adaptive path index (APEX ⁰ ) 12 is a graph structure, so that nodes of the graph structure have extents instead of having all of the set of edges of paths required. Here, the set of paths starting from the root among the paths of the XML graph is referred to as Q _XML , and the set of required paths defined as a path having a length of 1 or more than a user-defined minimum support is defined as R. Where the extent for path p is defined as E (p) = ∪ _{r∈Q (p)} T (r) and T (r) is the _edge set of path r, Q (p) = Q _G (p) -Q _A (p), for path p in set R, Q _G (p) = {l | l ∈ Q _XML and p is a suffix of l}, Q _A (p) = {l | l ∈ Q _XML and every path q (≠ p) ∈ R having p as a suffix is suffix of l}. The method of claim 5, The adaptive path index further includes a hash tree, the hash tree maintains information about required paths, and each node of the hash tree has a hash table, each of which is a hash table. The entry structure of the hash table includes a label field, a count field indicating at least the frequency of use for the required paths, a new field indicating whether a node is new, an xnode field pointing to a node of the graph structure, and a next node pointing to the next node. A method of performing an XML query using an adaptive path index, which stores a field and continuously updates the fields to reflect a change in the query load. The method of claim 6, The update of the adaptive path index searches for a hash tree entry for each node while searching the graph structure of the adaptive path index, so that nodes that are not frequently used are And removing and adding a new node to the graph structure.

Images