KR20080051063A - Method for managing intergrated xquery - Google Patents

Abstract

A method for processing an integrated XQuery(XML(eXtensible Markup Language) Query) is provided to process the continuous XQueries in an XML database based on a relational database and supporting an XQuery by loading a permanent node needed for processing the XQuery from XML data to a memory, forming an integrated XQuery result based on integrating a generated node result formed in the memory with a permanent node result, and utilizing the result as an intermediary result. A permanent node needed for processing an XQuery is loaded from a relational database to a memory as an intermediary result(108). An XQuery generator forms a new generated node in the memory as the intermediary result(109). Whole tree of an integrated XQuery result is formed by connecting the permanent node loaded from the relational database with the node generated from the XQuery generator when an XML path expression representing the permanent node of the relational database is used in the XQuery generator(111). A continuous XML path expression query is processed by using the integrated XQuery result as the intermediary result.

Description

How to handle integrated query queries {METHOD FOR MANAGING INTERGRATED XQUERY}

The present invention relates to an integrated XQuery query processing method.

The present invention is derived from the research conducted as part of the IT new growth engine core technology development project of the Ministry of Information and Communication and the Ministry of Information and Communication Research and Development. .

In recent years, as the Internet spreads, the generation and distribution of XML data has rapidly increased, and accordingly, there is a need for managing a large amount of XML data. Therefore, as the amount of XML data managed increases, the management functions provided by the existing relational database such as data retrieval, sharing among multiple users, backup and recovery in case of failure are needed. Research is being actively conducted.

In an XML database that manages a large amount of XML data, since a search is performed on a large amount of XML data, the results often become large depending on the search condition or the user's result return request form.

In particular, for XML databases based on relational databases that support complex query features such as path expressions and FLWOR clauses, persistent node results at once in a relational database for processing a single XQuery statement. Rather than being able to process XQuery queries in a way that yields a final result and then produces a final result, in the process of processing the main syntax of an XQuery statement, it continues to access a relational database to produce partially intermediate results. You have no choice but to perform query processing in such a way as to continuously execute query processing to produce the final XQuery result.

As described above, in a query processing method in which a complex XQuery query statement continues to produce intermediate results from a relational database, and continuous query processing for intermediate results produces a final result, a persistent node result obtained from a relational database is possible. Performing XQuery query processing with a small amount of memory and loading it into memory is the most important way to improve XQuery query processing performance.

In an XML database based on a conventional relational database, an attempt is made to improve search performance by generating and executing an optimized query execution plan to reduce the number of results passed from the relational database to the XML database or to reduce query processing time. We're working on it, but we're dealing with the intermediate and final search results that are mostly loaded into memory at once.

However, due to the nature of the XML model with a tree structure, if the node corresponding to the search result is a node having many child and descendant nodes, that is, a large subtree, if such a subtree is loaded into memory, there are still too many results. do. Also, most of the many nodes in the subtree are often unnecessary nodes for continuous query processing.

Therefore, even if the XQuery query processing system of the XML database performs an optimized search, if the entire intermediate result subtree is loaded into memory all at once, a serious fatal problem occurs, and the entire subtree of the intermediate result node is stored in memory at once. Rather than loading it, it is preferable to create and load only the intermediate result nodes that are needed.

In addition, XQuery provides a constructor function to reconstruct search results. When using a constructor in an XQuery query statement, the new generation node result is configured in memory along with the persistent node result configured from the relational database. And persistent nodes are related to each other in a parent / child node relationship or in an owning element / dependent attribute relationship to form a complete XQuery result.

In this way, the integrated XQuery result, which is composed of the persistent node in association with the generation node, is utilized as an intermediate result, and then continues with the query processing process. In the XQuery query processing system of the XML database, the persistent node, the generation node, or the persistent node There is a need for a method that can perform query processing regardless of the node type, such as an integrated XQuery result node combined with a generation node.

Therefore, in the present invention, only persistent nodes necessary for XQuery query processing are loaded into memory from XML data managed permanently in a relational database, and integrated XQuery results are formed by integrating persistent node results and generation node results configured by the XQuery constructor. In addition, the integrated XQuery result configured as above is used as an intermediate result to suggest a way to obtain a final XQuery result by performing continuous XQuery query processing.

The present invention has been proposed to solve the above problems, and in an XML database based on a relational database and supporting XQuery as a query language, only persistent nodes necessary for processing XQuery queries from XML data managed in the relational database are stored. It provides a method of constructing an integrated XQuery result by integrating the resultant node result configured in memory by the XQuery constructor with the persistent node result, and using it as an intermediate result to perform continuous XQuery query processing. The purpose is.

In order to achieve the above object, the integrated XQuery query processing method according to the present invention is a persistent node required for processing a query from the relational database as an intermediate result in the process of processing the XML path expression targeting the persistent XML data of the relational database. The first step of taking only and loading it into memory; In the processing of the XQuery constructor, a second step of configuring a new generation node in memory as an intermediate result; When an XML path expression representing a persistent node of a relational database is used inside an XQuery constructor, a third tree that constructs the entire tree of integrated XQuery results by concatenating the persistent node obtained from the relational database to a generation node generated from the XQuery constructor. step; And a fourth step of processing the continuous XML path expression query utilizing the integrated XQuery result as an intermediate result.

As described above, the present invention is based on a relational database, and in an XML database supporting XQuery as a query language, by loading only the persistent nodes necessary for loading a memory of persistent node results from the XML data persistently managed in the relational database. Even if a persistent node loaded in memory is a non-terminal node, all the child and descendant nodes are not obtained, but only the persistent node can be processed to continue the query processing. This has the effect of improving performance, and also enables consistent query processing on integrated XQuery results that integrate persistent and resultant node results.

The above objects, features, and advantages will become more apparent from the following detailed description taken in conjunction with the accompanying drawings, whereby those skilled in the art may easily implement the technical idea of the present invention. There will be. In addition, in describing the present invention, when it is determined that the detailed description of the known technology related to the present invention may unnecessarily obscure the gist of the present invention, the detailed description thereof will be omitted. Hereinafter, various exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is a flowchart illustrating a process of constructing an integrated XQuery result by integrating a persistent node result from a relational database and a resultant node result by an XQuery constructor according to the present invention.

As shown in FIG. 1, the method for constructing an integrated XQuery result according to the present invention comprises the steps of constructing a parsing tree by parsing an XQuery query input by a user (102), visiting nodes of the parsing tree one by one. Performing 103 XQuery query processing; and determining 104 whether the visited node is the last node of the parse tree.

The integrated XQuery result construction method according to the present invention includes the step 105 of checking the node type of the visited node when the determination result is not the last node, and as a result of the determination, the node type of the visited node. In the case of this constructor, a generation node is configured (109), and when the visited node type is a path expression, it is determined what the query target is (106).

In the integrated XQuery result construction method according to the present invention, when the query target is a persistent node, the persistent node is obtained from a database and configured in a memory (108), and when the query target is a generation node. All nodes of the generation node tree already configured in memory are visited and a result node is constructed (107).

The integrated XQuery result construction method according to the present invention, if the above-described processes of 106, 107, 108, and 109 are completed, checks whether it is inside a generator (110), and if it is inside the inspection result generator, generates a configuration configured in the memory. The node or persistent node is connected with the higher generation node (111), and if the check result generator is not inside, the process returns to step 103.

Finally, in step 103, if it is determined that the visited node is the last node (104), the XQuery query processing procedure is terminated (112).

Among the above-described processes, the process 111 of connecting the generation node or the persistent node with the parent generation node in the constructor may be based on a parent according to the Document Object Model (DOM) standard or the XQuery Data Model (XDM) standard established by the W3C. It can be a / child node or owned element / dependent attribute relationship, depending on the node type of the producing node and the node type of the persistent node. The node type of the generation node and the node type of the persistent node will be described in detail with reference to the inheritance and association diagrams of the persistent node and the generation node of FIG. 8 described later.

FIG. 2 is an embodiment of XML data persistently managed in an XML database based on a relational database in order to explain the integrated XQuery result construction and query processing method according to the present invention.

As shown in FIG. 2, any XML data has a root element of "users" element 201 and a "users" element 201 of three "users". "Elements 202-1, 202-2, and 202-3 as child nodes, and each" user "element 202-1, 202-2, and 202-3 have different values. "id" elements 203-1, 203-2, 203-3, "name" elements 205-1, 205-2, 205-3, "rating" elements 204-1 , 204-2, 204-3) as child nodes.

3 is an embodiment of an XQuery query that requires integration of persistent node results from a relational database with generation node results by an XQuery constructor in order to illustrate a method of constructing and querying integrated XQuery results in accordance with the present invention. This is an XQuery query statement meaning to return the name 205-1 of the user 202-1 whose identifier is "U01" among all users managed in the XML data of 2.

The XQuery query 301 shown in FIG. 3 includes three path expressions as follows.

-fn: doc ('users.xml') / users / user

-$ user / id

-$ user / name

As such, multiple XML path expressions can be used in a single XQuery query, associating each other with variables, and the $ user / name path expression 303 used in the return clause at the end produces the final result. A path expression that is used, but other path expressions are path expressions that produce intermediate results before producing the final result.

Thus, in one XQuery query, the path expression that produces the final result is used, and the path expression that produces only the intermediate result is not included in the final result. In other words, when processing an XQuery query in an XML database based on a relational database, in the process of processing one XQuery query, the persistent node, which is an intermediate result from the relational database, is loaded into memory several times. To be used as a target for processing.

In this situation, importing all of the subtrees of the nodes represented by the path expressions in a relational database can be a performance penalty since unnecessary nodes are loaded into memory from the database. For example, the first path expression of FIG. 3 returns all user elements as intermediate results, and the user element has id, name, and rating elements as child nodes. Of the above elements, the id and name elements are used in the where and return clauses, respectively, but the rating element is not used at all to produce the final XQuery result. Therefore, producing only nodes that satisfy each path expression as intermediate results can improve overall XQuery query processing performance by not loading nodes that are not needed right now into the memory from the relational database.

4 shows the appearance of the integrated XQuery result obtained as the final result of processing the XQuery query 301 of FIG. The integrated XQuery result of FIG. 4 is associated with a parent / child relationship between the results element 401, which is a generation node configured by the XQuery constructor, and the user element 402, which is a persistent node loaded into memory from XML data managed in a relational database. The entire result tree is organized. The user element 402, which is a persistent node, has id, name, and rating elements 403, which are persistent nodes, as child nodes in relations between persistent nodes in a relational database. It is not included in the tree representing the final query processing result. It is loaded into memory and provided to the user when the user finally gets the result.

FIG. 5 illustrates the integrated XQuery result by combining persistent node results from a relational database and generation node results by an XQuery constructor to explain the integrated XQuery result construction and query processing method according to the present invention. An embodiment of an XQuery query that performs a query on an additional XQuery expression by utilizing it as an intermediate result (501), and means to return the name of the user whose identifier is 'U01' among all users managed in the XML data of FIG. This is an XQuery query having the same meaning as the XQuery query of FIG. 3 having a different syntax.

In the query of Fig. 5, the path expression " \ r / user / id /.." 503 obtains the persistent node user, which is the child node, for the result node 502, which is the producing node, and obtains the id, which is the persistent node, of the child node. This means to get the parent node, the persistent node user. However, if the query is $ r / user / .., then the resultant node user (s) for the resultant node results (502) should be found and the resultant node results (502) that is its parent node. In this case, finding the user of the persistent node parent of the persistent node user would be wrong.

Therefore, in order to solve such a problem, in the present invention, when a persistent node loaded in a memory is referred to in the XQuery constructor, the parent node is created as an attribute of the persistent node so as to associate a relationship with the parent generation node. Reference and creation owned element reference, which will be described in detail with reference to FIG.

6, 7 and 8 show that in an XML database based on a relational database and supporting XQuery as a query language, less intermediate persistence results are stored in memory from possible relational databases, and are generated by the XQuery constructor. It is a data structure for constructing and managing intermediate results proposed by the integrated XQuery result composition and query processing method of the present invention to express structure information as meaning in an XQuery query statement between a node and a persistent node loaded from a relational database.

6 is a diagram illustrating an embodiment of an XQuery result item proposed by the integrated XQuery result configuration and query processing method according to the present invention.

The XQuery Result item 601 according to the present invention may be constructed as a Constructed Node 602, Persistent Node 603, or Atomic Value 604, depending on the node type. The atomic value 604 is obtained as an XQuery result, and the atomic value 604 is a non-node atomic type, that is, an integer 606, a float 607, a string 605, and the like. The atomic type follows the XML Schema standard established by the W3C.

7 is a diagram illustrating an embodiment of an XQuery result order sequence proposed by the integrated XQuery result structure and query processing method according to the present invention.

The XQuery result sequence 701 according to the present invention is an order sequence in which the included XQuery result items 702 have an order, and according to the node type of each XQuery result item 702, the generation node 704 and the persistent node ( 705, 706), the integration node tree 704 or the atomic value 703, in which the generation node and the persistent node are integrated, will have an XQuery result.

As described above, in the case of an integrated XQuery result, the parent child relationship is expressed between the generating nodes or between the generating node and the persistent node, and the parent child relationship by the memory reference is represented by the generating parent node reference property and the child node reference property. The parent child relationship between the node and the persistent node is expressed as a node identifier, not as a memory reference relationship. In addition, as described above, the child and descendant nodes 706 of the persistent node 705 loaded in the memory are loaded into the memory when necessary, so as to avoid unnecessary memory loading of the node.

8 illustrates a data structure of a generation node (CNode) 801 and a persistent node (XNode) 810 representing an XQuery result proposed by the integrated XQuery result construction and query processing method according to the present invention, and a generation node 801. Is an exemplary relationship diagram illustrating a relationship between a persistent node and a persistent node 810.

As shown in FIG. 8, the node types of the generation node 801 include a CElement 802, an attribute, a CAttribute, a comment, a processing instruction, a text, and a text. The node types of the node 810 include an element (XElement) 811, an attribute (XAttribute) 812, an comment (XComment) 813, an XProcesing Instruction 814, and a text (XText) 815. There is a document node (XDocument) 816.

The parent-child relationship between a persistent node and a persistent node is distinguished by a node identifier uniquely owned by the persistent node, and is not represented by a memory reference relationship.

The parent child relationship between the producing nodes is represented by the generating parent node reference attribute and the child node reference attribute that the producing node has as attributes, and the parent child relationship between the producing parent node and the persistent child nodes is created by the persistent node as an attribute. It is represented by the parent reference attribute and the child node reference attribute of the creating node. In other words, a persistent node will have a managed parent node in the relational database if the creating parent node reference does not exist, and if it has a creating parent node reference during the constructor processing, it will lose the persistent parent node it had. Has the property of having as its parent node.

As described above, the relationship between the parent node and the child node of the generation node and the persistent node is as follows.

The parent node of the producing node may or may not exist.

-The child node of the creation node is not a creation node, a persistent node or exists.

A parent node of a persistent node is basically a persistent node or does not exist, but a generation node may be a parent node during query processing.

A child node of a persistent node is always a persistent node or does not exist.

FIG. 9 is an embodiment of a flowchart illustrating a process of searching for child nodes by performing continuous XQuery query processing on an integrated XQuery intermediate result having data structures as illustrated in FIGS. 6, 7, and 8.

When the XQuery query processing system starts the child node search process (901), the node type of the input node is checked (902).

If the node type of the check result input node is a generation node, all child nodes that the generation node has as a memory reference are searched and added to the final search result (904). Or, if the node type of the check result input node is a persistent node, all persistent child nodes of the input node are checked in the relational database and added to the final search result (906). Subsequently, the child node search process is terminated by providing the final search result to the user (905).

FIG. 10 is an embodiment of a flowchart illustrating a process of searching for descendant nodes by performing continuous query processing on an integrated XQuery intermediate result having a data structure as shown in FIGS. 6, 7, and 8.

When the XQuery query processing system starts the child node search process (1001), the node type of the input node is checked (1002).

If the node type of the input node is a persistent node, if the node type of the input node is a persistent node, all child nodes are searched for in the relational database and added to the search result (1010). If the node type is a generation node, the existence of a child node of the generation node is checked (1004).

It is determined whether the child node exists (1005), and if there is a child node, all child nodes that have a memory reference are added to the search result list (1006), and the node type is checked for each child node (1007). ). On the other hand, if the child node does not exist, the search result is provided (1008) and ends (1011).

The node type of the child node is examined to determine the node type (1007, 1009). If the result of the determination is that the child node is a generation node, the child node is again examined for the existence of the child node (1004). If the result of the determination is that the child node is a persistent node, all child nodes are searched in the relational database and searched for in the search result. After adding (1010) and providing the search results (1011), the child node search process ends (1011).

FIG. 11 is an embodiment of a flowchart illustrating a process of searching a parent node by performing continuous query processing on an integrated XQuery intermediate result having a data structure as shown in FIGS. 6, 7, and 8.

The XQuery query processing system determines the node type by checking the node type of the input node when the parent node search process is started (1101) (1102, 1103).

If the node type of the input node is the generation node as a result of the determination, the parent node which the generation node has as the memory reference is searched for and provided as a search result (1104). Alternatively, if the node type of the input node is a persistent node as a result of the determination, it is checked whether a persistent parent node of the persistent node is referenced (1105 and 1106).

As a result of the creation parent node reference check, if the generation parent node reference does not exist, the parent node is searched for in the relational database and provided as a search result (1107). 1104, the parent node search process ends (1108).

FIG. 12 is an embodiment of a flowchart illustrating a process of searching an ancestor node by performing continuous query processing on an integrated XQuery intermediate result having a data structure as shown in FIGS. 6, 7, and 8.

When the ancestor node search process starts (1201), the XQuery query processing system examines the node type of the input node and determines the node type (1202, 1203).

If the node type of the input node is a generation node as a result of the determination, it is checked whether a generation parent node exists (1204 and 1205). If the check result generation parent node exists, the parent node is added to the search result (1209), and the added parent node is checked again for the existence of the generated parent node (1204). Meanwhile, when the test result generation parent node does not exist, an ancestor node search result list is provided as a search result (1206).

Or, if the node type of the input node is a persistent node as a result of the determination, it is checked whether a generation parent node exists (1207, 1208). If the check result generation parent node exists, the parent node is added to the search result list (1209), and the generated parent node is checked again for the existence of the generation parent node (1204). On the other hand, if the parent node does not exist as a result of the inspection, the ancestor node search process is terminated by searching for all ancestor nodes in the relational database (1210) and providing them as a search result (1206).

The method of the present invention as described above may be implemented as a program and stored in a recording medium (CD-ROM, RAM, ROM, floppy disk, hard disk, magneto-optical disk, etc.) in a computer-readable form. Since this process can be easily implemented by those skilled in the art will not be described in more detail.

The present invention described above is capable of various substitutions, modifications, and changes without departing from the technical spirit of the present invention for those skilled in the art to which the present invention pertains. It is not limited by the drawings.

Those skilled in the art will appreciate that various modifications or changes can be made without departing from the scope and spirit of the invention. Those skilled in the art will understand the specific details of the present invention and the embodiments disclosed herein, and that other embodiments of the present invention are possible.

1 is a flowchart illustrating an integrated XQuery result construction process for integrating and managing a persistent node result and a generation node result according to the present invention.

FIG. 2 is an embodiment XML data structure diagram illustrating an integrated XQuery result construction and query processing method for integrating and managing a persistent node result and a generation node result according to the present invention. FIG.

FIG. 3 is an exemplary XQuery query structure diagram for an XML document of FIG. 2 illustrating a method of constructing and processing an integrated XQuery result for integrating and managing a persistent node result and a generated node result according to the present invention. FIG.

4 is an embodiment generated after query processing the XQuery query statement of FIG. 3 for explaining an integrated XQuery result construction and query processing method for integrating and managing a persistent node result and a generation node result according to the present invention. Integrated XQuery result tree schematic.

5 is an exemplary XQuery query structure diagram for explaining an integrated XQuery result construction and query processing method for integrating and managing a persistent node result and a generated node result according to the present invention.

FIG. 6 is a diagram illustrating an exemplary XQuery result item configuration for explaining an integrated XQuery result construction and query processing method for integrating and managing a persistent node result and a generation node result according to the present invention. FIG.

FIG. 7 is a diagram illustrating an exemplary XQuery result sequence structure for explaining an integrated XQuery result construction and query processing method for integrating and managing a persistent node result and a generation node result according to the present invention. FIG.

8 is an embodiment relationship diagram illustrating inheritance and association of persistent and generated nodes for explaining an integrated XQuery result configuration and query processing method for integrating and managing persistent node results and generated node results according to the present invention. .

9 is a flowchart illustrating a process of searching for a child node in an integrated XQuery result construction and query processing method for integrating and managing a persistent node result and a generation node result according to the present invention.

10 is a flowchart illustrating a process of searching for descendant nodes in an integrated XQuery result construction and query processing method for integrating and managing a persistent node result and a generated node result according to the present invention.

11 is a flowchart illustrating a process of searching for a parent node in an integrated XQuery result construction and query processing method for integrating and managing a persistent node result and a generation node result according to the present invention.

12 is a flowchart illustrating a process of searching for an ancestor node in an integrated XQuery result construction and query processing method for integrating and managing a persistent node result and a generation node result according to the present invention.

Claims (8)

In the process of processing the XML path expression for querying the persistent XML data of the relational database, a first step of taking only the persistent node necessary for query processing from the relational database as an intermediate result and loading it into memory; In the processing of the XQuery constructor, a second step of configuring a new generation node in memory as an intermediate result; When an XML path expression representing a persistent node of a relational database is used inside an XQuery constructor, a third tree that constructs the entire tree of integrated XQuery results by concatenating the persistent node obtained from the relational database to a generation node generated from the XQuery constructor. step; And A fourth step of processing the continuous XML path expression query utilizing the integrated XQuery result as an intermediate result Integrated XQuery query processing method, including. The method of claim 1, wherein the first step, When a reference to a persistent node occurs inside the XQuery constructor, an integrated XQuery query processing is performed by associating a parent child relationship with a parent generation node through a creation parent node reference attribute of the persistent node and a child node reference attribute of the creation node. Way. The method of claim 1, wherein the second step, A method of processing integrated XQuery by associating parent child relationships between nested generation nodes through generation parent node reference attributes and child node reference attributes using generation nodes configured in the memory. The method of claim 1, In revealing the structural relationship between the persistent node and the generation node that constitutes the integrated XQuery result, And a fifth step of retrieving at least one of a child node, a child node, a parent node, and an ancestor node of a specific node with respect to an integrated XQuery result in which the persistent node and the generation node are integrated. The method of claim 4, wherein In the case where the search target is the child node in step 5, A sixth step of checking a node type of the input node; A seventh step of searching for and adding all child nodes which the generation node has as a memory reference to the final search result if the node type of the check result input node is a generation node; An eighth step of checking all persistent child nodes of the input node in the relational database and adding them to a final search result if the node type of the input node is a persistent node; And And a ninth step of providing the final search result to a user. The method of claim 4, wherein In the case where the search target is a descendant node in step 5, A tenth step of checking a node type of the input node; An eleventh step of checking whether or not a child node of a generation node exists if the node type of the input node is a generation node; Twelfth step of adding all child nodes which have a memory reference to a search result list and checking the node type for each child node if the check result exists; A thirteenth step of providing a search result to a user if there is no child node as a result of the inspection; A fourteenth step of checking whether the child node exists again if the child node is a generation node as a result of the node type check of the child node; And And if the child node is a persistent node as a result of the node type check of the child node, searching for all the child nodes in the relational database, adding the search result to the search result, and then providing a search result. The method of claim 4, wherein In the case where the search target is a parent node in step 5, A fifteenth step of checking a node type of the input node; A sixteenth step of searching for a parent node which the generation node has as a memory reference and providing it as a search result if the node type of the check result input node is a generation node; A 17th step of checking whether a generation parent node of the persistent node is referenced if the node type of the input node is the persistent node as a result of the checking; An eighteenth step of searching for a parent node in a relational database and providing it as a search result if the generated parent node is not present; And And a nineteenth step of providing, as a search result, a generation parent node having a memory reference if the result of the generation parent node exists. The method of claim 4, wherein In the case where the search target is a parent node in step 5, A twenty step of checking a node type of the input node; A twenty-first step of checking whether a generation parent node exists if the node type of the input node is a generation node; A twenty-second step of adding a parent node to a search result and checking the existence of the generated parent node again with respect to a parent node if a parent node exists as a result of the check for existence of the generated parent node; Providing a list of ancestor node search results as a search result if the parent node does not exist; A twenty-fourth step of checking whether a generation parent node exists if the input node is a persistent node as a result of the node type checking; A twenty-fifth step of adding a parent node to a search result list and checking whether the generated parent node exists again if the generated parent node exists; And If the parent node does not exist, further comprising a twenty-sixth step of retrieving all ancestor nodes from a relational database, adding them to a list of results and providing them as a search result.

Images