KR20120073651A - Apparatus and method for processing sparql queries for searching keyword - Google Patents

Abstract

PURPOSE: A SPARQL(SPARQL Protocol and RDF Query Language) query processing device and a method thereof are provided to perform efficient keyword search in an RDF graph structure. CONSTITUTION: A node number setting unit(110) is defined by resource/attribute/attribute value on an RDF(Resource Description Framework) document and sets up a node number in a tree structure. A node group forming unit(120) forms a node group as a member node based on a keyword inputted from a user. A node set forming unit(130) selects the member node as the node group based on the node number.

Description

APPARATUS AND METHOD FOR PROCESSING SPARQL QUERIES FOR SEARCHING KEYWORD}

Embodiments of the present invention relate to an apparatus and method for performing SPARQL query processing for keyword search, and more particularly, to an apparatus and method for performing SPARQL query processing for performing an efficient keyword search in a resource description framework (RDF) graph structure. It is about.

In general, keyword search is a term used in the field of information retrieval and is a query processing technique for retrieving a document including one or more keywords by listing one or more keywords input from a user.

Such a search technique has an advantage that a user can easily perform a search even if the user does not have prior knowledge of a complex query language or data structure. Due to these advantages, research on keywords is being actively conducted on relational databases or XML (eXtensible Markup Language) databases.

In the case of keyword search for structured data, when a user enters a predetermined keyword, an infrastructure including all of the keywords is extracted from the structured data and returned to the user. For example, when a keyword search is performed on a relational database, a result including all keywords among the results of joining tuples along a foreign key reference is returned. In a keyword search technique for XML having a tree structure or a graph structure, a subtree including all keywords is returned.

To perform a query in a traditional search, you must have a prior knowledge of SQL (Structured Query Language) query language, and a prior knowledge of XQuery to perform a query against an XML database. On the other hand, if a keyword search for structured data is supported, it is possible to search the relation between query keywords without information on the structure of the data, and keyword search is possible even without a special query language.

Recently, with the emergence of the Semantic Web, an intelligent web, a new kind of structured Resource Description Framework (RDF) has been proposed. RDF is a language that describes information (property) about resource through graph structure so that computer can understand.

In addition, RDF / S (Resource Description Framework Schema) is declared to declare vocabularies defined in metadata. A vocabulary is a set of metadata elements defined by each metadata type for describing a resource as a set of attributes. OWL (Ontology Web Language) supports "owl: TransitiveProperty", "owl: SymmetricProperty", "owl: SameAs", etc. to extend RDF / S and semantically describe web resources.

As a query language for RDF data, there is SPARQL that describes desired data in the form of a graph pattern. Supporting keyword search for RDF data also allows users to easily search for RDF data without prior knowledge of the query language SPARQL.

However, there are some problems in applying the existing keyword search technique for structured data to RDF data.

BLINKS, which proposed keyword search in RDF graph, has a problem that it is difficult to maintain because the index is too large because it must compose keyword-node list index and node-keyword list index. Here, nodes are defined by resource / attribute / attribute values on the RDF document.

Next, since the RDF graph is a direct graph structure, there are disadvantages in maintaining all paths.

In addition, the keyword search method in XML uses an XML node-based label numbering index, which is difficult to apply to an OWL document having a triple graph structure because it is an XML tree-based index.

In order to solve the problems of the prior art as described above, the present invention proposes an apparatus and method for performing a SPARQL query processing to enable efficient keyword search in the Resource Description Framework (RDF) graph structure.

Other objects of the present invention may be derived by those skilled in the art through the following examples.

In order to achieve the above object, according to a preferred embodiment of the present invention, each node is defined for each of a plurality of nodes defined by resource / property / property values in an RDF document and arranged in a looped tree structure (loop tree structure). A node number setting unit for setting a node number including a way number and a minimum path length number, wherein the minimum path length number has the same length as the dewway number and is one of at least one node represented by the dewway number. Includes a minimum path length to each of the above nodes; A node group forming unit for forming n node groups corresponding to each of the n keywords and including one or more of the nodes as member nodes based on n keywords input from a user; A node set forming unit which selects one member node from each of the n node groups using the node number to form m node sets including n member nodes; For each of the m node sets, a minimum path length between a member node of a first node group and a member node of a last node group included in the node set is calculated, and the calculated minimum path length is set for each of the m node sets. A node set value setting unit set to be; And performing SPARQL query processing using the minimum set value among the set values of the m node sets, the member node of the first node group in the node set having the minimum set value, and the member node of the last node group. A SPARQL query processing execution apparatus for keyword search including a portion is provided.

The node group forming unit may include, as a member node of the j-th node group, a node including an attribute value of the j-th keyword among the plurality of nodes.

The minimum path length number is composed of an array of 0 or 1 or more numbers, and a number other than 0 of the k (which is an integer of 1 or more) included in the minimum path length number for any one of the plurality of nodes is It may mean a minimum path length between the node represented by the k-th number from the first number included in the dway number for the one node and the one node.

The node set forming unit may select a member node having a minimum path length with a member node of the j-1 th node group included in the i th node set among one or more member nodes in the j th node group. It can be selected as a member node of the j-th node group included in the i-th node set.

The node set forming unit preferentially calculates a minimum path length between any member node in the j-th node group and member nodes of the j-1 th node group included in the i-th node set by using the minimum path length number. If the minimum path length between the one of the member node and the member node of the j-1 node group included in the i-th node set can not be calculated using the minimum path length number, The minimum path length between any one member node and the member node of the j-1 th node group included in the i th node set may be calculated using the number.

The node set forming unit aligns one or more member nodes in the j-th node group according to the minimum path length to the node forming the root node of the loop tree among the plurality of nodes using the node number, By applying a binary search technique to one or more member nodes in the j-th node group, a member node having a minimum path length with the j-1 th member node included in the i-th node set may be selected.

The node set forming unit preferentially calculates a minimum path length between any one member node and the root node in the j-th node group using the minimum path length number, and uses the minimum path length number. When the minimum path length between the member node and the root node cannot be calculated, the minimum path length between any one member node and the root node may be calculated using the dewway number.

The node set value setting unit includes at least one reference for each node set having at least a part of a common part of a node number of a member node of the first node group and a node number of a member node of the last node group. Configure a node, and set a first minimum path length between each member node of the first node group and each of the at least one reference node and a second minimum path length between each member node and the at least one reference node of the last node group. The minimum value of the sum of the first minimum path length and the second minimum path length corresponding to each other may be calculated as the minimum path length between the member node of the first node group and the member node of the last node group. have.

The number of the at least one reference node is a position where the number of zeros is first arranged starting from the position corresponding to the last digit of the common part of the way number among the minimum path length numbers for the member nodes of the first node group. The number from 0 to the position where the number of 0 is first arranged, starting from the position corresponding to the last digit of the common part of the number among the minimum path length number for the member node of the last node group. The number may correspond to a smaller value.

The number of m node sets may be equal to the number of member nodes included in the first node group, and the member nodes of the first node group included in the m node sets may be different from each other.

The first node group may be a node group having the minimum number of member nodes among the n node groups.

In addition, according to another embodiment of the present invention, the draw number and the minimum path length for each of a plurality of nodes defined by resource / property / property values and arranged in a looped tree structure (loop tree structure) on an RDF document. Setting a node number including a number, wherein the minimum path length number has the same length as the dew number and indicates a minimum path length to each one or more nodes of at least one node represented by the dew number. Includes-; Forming an n node group corresponding to each of the n keywords and including one or more of the nodes as member nodes based on n keywords input from a user; Selecting one member node from each of the n node groups using the node number to form a set of m nodes (which are integers of 1 or more) including n member nodes; For each of the m node sets, a minimum path length between a member node of a first node group and a member node of a last node group included in the node set is calculated, and the calculated minimum path length is set for each of the m node sets. Setting to; And performing SPARQL query processing using the minimum set value among the set values of the m node sets, the member node of the first node group in the node set having the minimum set value, and the member node of the last node group. A method of performing SPARQL query processing for a keyword search is provided.

According to the present invention, it is possible to perform an efficient keyword search in the RDF graph structure.

1 is a block diagram illustrating a detailed configuration of an SPARQL query processing apparatus for keyword search according to an embodiment of the present invention.
FIG. 2 is a diagram showing an example of LDNs given to a plurality of nodes and a plurality of nodes forming a loop tree structure on an RDF document.
3 and 4 are diagrams for explaining a concept of forming a node set and n node groups configured according to an embodiment of the present invention.
5 is a flowchart illustrating the overall flow of a method for performing SPARQL query processing for keyword search according to an embodiment of the present invention.

As the invention allows for various changes and numerous embodiments, particular embodiments will be illustrated in the drawings and described in detail in the written description. It should be understood, however, that the invention is not intended to be limited to the particular embodiments, but includes all modifications, equivalents, and alternatives falling within the spirit and scope of the invention. Like reference numerals are used for like elements in describing each drawing.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is a block diagram illustrating a detailed configuration of an SPARQL query processing apparatus (hereinafter, referred to as an "SPARQL query processing apparatus") for keyword search according to an embodiment of the present invention.

Referring to FIG. 1, the SPARQL query processing apparatus 100 according to an exemplary embodiment may include a node number setting unit 110, a node group forming unit 120, a node set forming unit 130, and a node set value setting. The unit 140 and the query processing unit 150 is included. Hereinafter, the function of each component will be described in detail.

The node number setting unit 110 sets a node number for each of a plurality of nodes defined by a resource / property type / value on a resource description framework (RDF) document.

Here, the plurality of nodes basically have a tree structure (indicated by a solid line) as shown in FIG. 2, but the root node is connected to any one child node to form a loop (indicated by a dotted line). That is, the plurality of nodes are connected according to the tree structure in which the loop is formed (loop tree structure).

The node number also includes a Dewey Number (DN) and a Minimal Path Length Number (MPLN).

DN is a number assigned to each node in a general RDP document (graph). The MPLN has a length equal to the DN, and is a number including a minimum path length to each of one or more nodes among the at least one node represented by the DN. 2 shows examples of node numbers including a DN and an MPLN.

Referring to Fig. 2, a node number indicated by a rectangle is shown adjacent to each node indicated by a circle. The number array displayed at the top of the node number is DN, and the number array displayed at the bottom is MPLN.

As shown in FIG. 2, the MPLN is represented by the same number of numeric arrays as DN (ie, have the same length), and the arrayed numbers have a value of 0 or 1 or more.

Here, k (the integer greater than or equal to 1) among the numbers except 0 is the minimum path length between the node represented by the k th digit from the first digit of the DN and the corresponding node. If the kth digit of the MPLN is 0, it means that the minimum path length with the node represented by the kth digit from the first digit of the DN is not calculated.

For example, for node c, the first digit of the MPLN has a value of 1 and the remaining digits have a number of 0, so that between node c and the node represented by DN of "0" (that is, node a) The minimum path length of becomes 1, and the minimum path lengths of node C (ie, node b, node d, node e) and node C indicated by "0.0", 0.0.0 ", and" 0.0.0.2 "respectively are calculated. It is not.

As another example, for node e, the first digit of the MPLN has a value of 2, and the remaining digits have a number of 0, so that between node e and node e represented by DN of "0" (ie, node a). The minimum path length of becomes 2, and the minimum path lengths of the nodes (i.e., node b, node d) and node e respectively indicated by "0.0" and 0.0.0 "are not calculated.

In other words, a number other than 0 of the kth number included in the MPLN for any one node of the plurality of nodes is represented by the kth number from the first number included in the DN for the one node and the It means the minimum path length between any one node.

That is, the MPLN is a number reflecting the minimum length path changed by the loop formed on the tree structure, and can be easily used to reduce the amount of computation required to calculate the minimum path length between nodes as described below.

Hereinafter, for convenience of description, a node number including a DN and an MPLN will be referred to as a loopiness depth number (LDN).

The node group forming unit 120 forms n node groups that correspond to each of the n keywords and include one or more nodes as member nodes, based on n keywords (which are integers of 2 or more) input from the user.

As an example, when three keywords "B", "C", and "D" are input from the user, the node group forming unit 120 may include one or more nodes (LDNs) associated with each keyword as shown in FIG. And form a three node group including one or more selected nodes as member nodes.

Here, the nodes included in the node group corresponding to the predetermined keyword may be nodes including the corresponding keyword as an attribute value. That is, the node group forming unit 120 may include the node including the j-th keyword (which is an integer of 2 or more and n or less) among the plurality of nodes as a member node of the j-th node group.

Hereinafter, for convenience of description, in the example of FIG. 3, the node group corresponding to the keyword B is referred to as "node group B", the node group corresponding to the keyword C as "node group C", and the node group corresponding to the keyword D as ". Node group D ".

The node set forming unit 130 selects one member node from each of the n node groups using the LDN to form a set of m nodes (which are integers of 1 or more) including n member nodes.

According to an embodiment of the present invention, the number of m node sets is equal to the number of member nodes included in the first node group among the n node groups, and the member nodes of the first node group each included in the m node sets are mutually different. Can be different. That is, the node set forming unit 130 may generate a node set for each member node included in the first node group.

According to an embodiment of the present invention, the first node group may be a node group having the minimum number of member nodes among n node groups. This is to reduce the amount of computation in the node set value setting unit 140 to be described later. The node groups other than the first node group may be arbitrarily set in order.

That is, in the example of FIG. 3, the node set forming unit 130 may select the node group D having the smallest number of member nodes (= 4) as the first node group.

Hereinafter, an operation in which the node set forming unit 130 forms m node sets will be described in detail with reference to FIGS. 3 and 4.

First, the node set forming unit 130 arranges the node group having the minimum number of member nodes among the n node groups as the first node group, and arranges the remaining node groups in any order. This process is to reduce the amount of calculation of the node set value setting unit 140 as described above, which may be omitted by a user selectively.

As an example, when three keywords are input as described in the example of FIG. 3, the node set forming unit 130 may arrange three node groups as shown in FIG. 4A.

Next, the node set forming unit 130 has a minimum path length with the member node of the j-1th node group included in the i-th node set among one or more member nodes in the jth node group. A member node having a minimum of may be selected as a member node of the j th node group included in the i th node set.

In other words, the node set forming unit 130 selects the member nodes included in the node set according to the order of the node groups and includes them in the corresponding node set, but the next node whose minimum path length is the minimum and the member node selected in the previous node group. Member nodes of a group can be included in the node set.

To this end, the node set forming unit 130 preferentially determines the minimum path length between any one member node in the j-th node group and the member node of the j-1 th node group included in the i-th node set using the MPLN. If it is not possible to calculate the minimum path length between any one member node and a member node of the j-1th node group included in the i-th node set using the MPLN, the DN may be used. The minimum path length between the member node and the member node of the j-1th node group included in the i-th node set may be calculated.

For example, in the case of (a) of FIG. 4, when node (0.0.1 / 0.0.0) is first selected as a member of the first node set in node group D, node set forming unit 130 selects MPLN. Search for nodes in node group B that can calculate the minimum path length with node (0.0.1 / 0.0.0). Accordingly, the minimum length path between the node (0.0.1.2.0.0 / 2.0.0.2.0.0) and the node (0.0.1 / 0.0.0) included in the node group B is calculated (= 2).

Thereafter, the node set forming unit 130 calculates a minimum length path between the remaining nodes included in the node group B and the node (0.0.1 / 0.0.0) using the DN. As a result, the distance from the node (0.0.1.2 / 2.0.0.0) is 1, the distance from the node (0.0.1.2.0.0.0.0 / 4.0.0.0.0.0.0.0) is 5, and the distance from the node (0.0 / 0.0) is 1 The distance from the node (0.0.1.2.0.0.0.1.2 / 6.0.0.0.0.0.0.0.0) is 6, and the node (0.0.1.2.0.0.0.1.1 / 5.0.0.0.0.0.0.0.0) ) Is calculated as 6.

Of these, the node (0.0 / 0.0) and the node (0.0.1.2 / 2.0.0.0) was calculated to have the shortest path length with the node (0.0.1 / 0.0.0), the node set forming unit 130 is Include either node (0.0 / 0.0) or node (0.0.1.2 / 2.0.0.0) in the node set. As an example, the node set forming unit 130 may select a node (0.0 / 0.0) that is closer to the root node.

Subsequently, the node set forming unit 130 selects one node in the node group C having the shortest minimum path length with the node (0.0 / 0.0) selected in the node group B according to the same process as described above. Accordingly, in the node group C, the node (0.0.0 / 0.0.0) is selected.

Accordingly, the node set forming unit 130 converts [node (0.0.1 / 0.0.0), node (0.0 / 0.0), and node (0.0.0 / 0.0.0)] into one (first) node set. To form.

Meanwhile, according to another exemplary embodiment of the present invention, the node set forming unit 130 uses a binary search technique to reduce the amount of computation, and the member having the minimum path length with the j-1 th member node included in the i th node set is minimum. You can select a node within the j th node group. This will be described in more detail below.

First, the node set forming unit 130 sorts one or more member nodes in the j-th node group according to the minimum path length to the node forming the root node of the loop tree using the LDN.

According to an embodiment of the present invention, the node set forming unit 130 first calculates a minimum path length between any one member node and the root node in the j-th node group by using the MPLN, but uses the MPLN as described above. If the minimum path length between any one member node and the root node cannot be calculated, the minimum path length between any one member node and the root node can be calculated using the DN.

As an example, the node set forming unit 130 may arrange the member nodes in the node groups shown in FIG. 4A as shown in FIG. 4B.

In this regard, the sorting operation of member nodes of node group D will be described in more detail, firstly, the nodes (0.0.1.2.0.0.0.1 / 4.0.0.0.0.0.0.0) and the nodes (0.0.1.2.0.0.0.1.2). /5.0.0.0.0.0.0.0.0), since the minimum path length between the root nodes can be calculated using the MPLN, the minimum path length with the root nodes is set to 4 and 5 by the MPLN, respectively. In the case of nodes (0.0.1 / 0.0.0) and nodes (0.0.0.0.0 / 0.0.0.0.0), the minimum path length between the root nodes cannot be calculated using the MPLN (MPLN The value of the first digit is "0"), the minimum path length is set to 2 and 4 by DN, respectively. Therefore, in the case of node group D, the order of the minimum path lengths calculated as shown in FIG. 4 (b), that is, "node (0.0.1 / 0.0.0), node (0.0.0.0.0 / 0.0. 0.0.0), nodes (0.0.1.2.0.0.0.1 / 4.0.0.0.0.0.0.0), and nodes (0.0.1.2.0.0.0.1.2 / 5.0.0.0.0.0.0.0.0) " Will be aligned. The remaining node groups also sort member nodes in the same way.

Next, the node set forming unit 130 applies a binary search technique to one or more member nodes in the sorted j-th node group, thereby minimizing a minimum path length with the j-1 th member node included in the i-th node set. Select an in-member node.

As an example, in the case where the member nodes are arranged as shown in FIG. 4B, an operation of selecting one member node among the member nodes included in the node group B according to the binary search scheme will be described as follows.

The node set forming unit 130 has a median value (= 4) of a minimum path length between the node (0.0.1 / 0.0.0) included in the node group D and the root node among the six nodes included in the node group B. Calculate the minimum path length between nodes (0.0.1.2.0.0.0.0 / 4.0.0.0.0.0.0.0). Also in this case, MPLN is used preferentially, and DN is used only when MPLN is not available. Accordingly, the minimum path length between node (0.0.1 / 0.0.0) and node (0.0.1.2.0.0.0.0 / 4.0.0.0.0.0.0.0) is calculated as 5.

Subsequently, the node set forming unit 130 includes nodes (0.0.1.2 / 0.0.0) included in the node group D and nodes having a minimum path length between the root node and a value of 1 or more and 4 or less (0.0.1.2 / 2.0.0.0) and node (0.0.1.2.0.0 / 2.0.0.2.0.0) to calculate the minimum path length.

In this case, the minimum path length is set to 1 and 3, which is smaller than the previously calculated minimum path length (= 4), so that the node set forming unit 130 has a node having a minimum path length of 1 with the root node (0.0). Calculate the minimum path length between /0.0) and node (0.0.1 / 0.0.0).

In this case, since the minimum path length is calculated as 1, the node set forming unit 130 selects a node (0.0 / 0.0) closer to the root node as a member node to be included in the node set.

This operation can be equally applied in the formation of all node sets.

Through the above-described process, the node set forming unit 130 according to an embodiment of the present invention forms m node sets.

Subsequently, the node set value setting unit 140 calculates the minimum path length between the member node of the first node group and the member node of the last node group included in the node set for every m node sets, and calculates the calculated minimum path. Set the length to the set value of each set of m nodes.

According to one embodiment of the present invention, the node set value setting unit 140 includes at least some of the DNs of the member nodes of the first node group and the DNs of the member nodes of the last node group as DNs, for each node set. Set one reference node, and set the first minimum path length between the member node of the first node group and each of the at least one reference node and the second minimum path length between each member node and the at least one reference node of the last node group. The minimum value among the sum of the first minimum path length and the second minimum path length corresponding to each other may be calculated as the minimum path length between the member nodes of the first node group and the member nodes of the last node group.

In this case, the number of the at least one reference node is "a number starting from the position corresponding to the last digit of the part where the DN is common among the MPLNs for the member nodes of the first node group to the position where the number of zero is first arranged. And "the number of digits starting from the position corresponding to the last digit of the part where the DN is common among the MPLNs for the member nodes of the last node group" to the position where the number of zeros is first arranged. " Can correspond.

Hereinafter, member nodes (hereinafter, referred to as "first nodes") of the first node group included in the predetermined set group have an LDN of (0.0.0.0.0.0.0 / 0.0.0.0.1.0.0), and The member nodes (hereinafter referred to as "second nodes") of the last node group included in a given set group are (0.0.0.0.0.0.0.0.0.0.0 / 0.0.0.0.1.0.0.0.0.0.0) The operation of the node set value setting unit 140 will be described in more detail with reference to an example having the LDN.

In the first step, the node set value setting unit 140 sets a reference node whose DN is a portion (0.0.0.0.0.0.0) where the DNs of the two nodes are common.

At this time, since the MPLN including the non-zero number does not exist at the same position as the position of the last digit (7th digit) included in the DN of the corresponding reference node, the node set value setting unit 140 determines the DN. Calculates a first minimum path distance (= 0) between the first node and the reference node and a second minimum path distance (= 4) between the second node and the reference node, and adds the values to " 4 " Calculate.

Thereafter, in the second step, the node set value setting unit 140 sets a new reference node whose length of DN is reduced by one. That is, the node set value setting unit 140 generates a new reference node whose DN is (0.0.0.0.0.0).

At this time, since the MPLN including the non-zero number does not exist at the same position as the position of the last digit (6th digit) included in the DN of the new reference node, the node set value setting unit 140 again performs the DN. Calculates a first minimum path distance (= 1) between the first node and the reference node and a second minimum path distance (= 5) between the second node and the reference node, and adds the values to " 6 " To calculate.

Subsequently, in the third step, the node set value setting unit 140 sets a new reference node having the length of DN reduced by one again. That is, the node set value setting unit 140 generates a new reference node whose DN is (0.0.0.0.0).

At this time, since there is an MPLN containing a non-zero number at the same position as that of the last digit (5th digit) included in the DN of the new reference node (first node and second node), the node set value The setting unit 140 calculates a first minimum path distance (= 1) between the first node and the reference node and a second minimum path distance (= 1) between the second node and the reference node by using the MPLN. The sum is calculated to yield a value of "2".

Afterwards, since the first minimum path distance and the second minimum path distance are calculated using the MPLN, the node set value setting unit 140 no longer decreases the DN, and the minimum value (= 2) of the calculated three values is not reduced. Is calculated as the minimum path length between two nodes, and is set as the set value of the corresponding node set.

Meanwhile, in the above example, when the MPLNs of both nodes are used in the third step, the operation of obtaining the first minimum path length and the second minimum path length by reducing the DN is stopped. Even when MPLN is used, the operation of obtaining the first minimum path length and the second minimum path length by reducing the DN may be stopped.

This operation is equally applied to every node set, and accordingly, the node set value setting unit 140 may set the set value for each node set.

Finally, the query processing unit 150 uses the minimum set value among the set values of the m node sets, the member node of the first node group in the node set having the minimum set value, and the member node of the last node group. Performs SPARQL query processing.

The present invention relates to an operation of calculating a distance between a first node, a last node, and two included in a set of search words necessary to perform SPARQL query processing, and an operation of performing SPARQL query processing using the same is well known in the art. Therefore, in this embodiment, description of the operation for performing the SPARQL query processing will be omitted.

As described above, the SPARQL query processing apparatus according to an embodiment of the present invention provides meaningful information directly related to a keyword input by a user, and can be searched using only an index without searching the entire graph, which was a problem of the RDF graph. There is an advantage. In other words, LDN is assigned to each node of the RDF graph so that the distance between each node can be calculated quickly, and SPARQL is automatically extracted by extracting information with minimum distance of each node for keyword to search using binary search. By converting the query into a query, it is possible to reduce the amount of computation by searching without searching the cost of the entire graph search, which was a problem of the RDF graph.

5 is a flowchart illustrating the overall flow of a method for performing SPARQL query processing for keyword search according to an embodiment of the present invention. Hereinafter, a process performed in each step will be described.

First, in step S510, LDN including DN and MPLN is assigned to each of the plurality of nodes represented on the RDF document.

In step S520, based on the n keywords input from the user, n node groups corresponding to each of the n keywords and including one or more nodes as member nodes are formed.

In step S530, one member node is selected from each of the n node groups using the LDN assigned to each node to form a set of m nodes including n member nodes.

In operation S540, a set value is set for each m node sets.

In this case, in step S540, the minimum path length between the member node of the first node group and the member node of the last node group included in the node set is calculated, and the calculated minimum path length is set to each of the m node sets. Can be set.

Finally, in step S550, SPARQL query processing is performed using the minimum set value among the set values of the m node sets, the member node of the first node group and the member node of the last node group in the node set having the minimum set value. Perform

So far, embodiments of the SPARQL query processing method according to the present invention have been described, and the configuration of the SPARQL query processing apparatus 100 described above with reference to FIGS. 1 to 4 may be applied to the present embodiment as it is. Hereinafter, a detailed description will be omitted.

In addition, embodiments of the present invention may be implemented in the form of program instructions that may be executed by various computer means to be recorded on a computer readable medium. The computer readable medium may include program instructions, data files, data structures, etc. alone or in combination. The program instructions recorded on the medium may be those specially designed and constructed for the present invention or may be available to those skilled in the art of computer software. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tape, optical media such as CD-ROMs, DVDs, and magnetic disks, such as floppy disks. Examples of program instructions such as magneto-optical, ROM, RAM, flash memory, etc. may be executed by a computer using an interpreter as well as machine code such as produced by a compiler. Contains high-level language codes. The hardware device described above may be configured to operate as one or more software modules to perform the operations of one embodiment of the present invention, and vice versa.

As described above, the present invention has been described with reference to particular embodiments, such as specific elements, and limited embodiments and drawings. However, it should be understood that the present invention is not limited to the above- Various modifications and variations may be made thereto by those skilled in the art to which the present invention pertains. Therefore, the spirit of the present invention should not be limited to the described embodiments, and all of the equivalents or equivalents of the claims as well as the claims to be described later will belong to the scope of the present invention. .

100: SPARQL query processing unit 110: node number setting unit
120: node group forming unit 130: node set forming unit
140: node set value setting unit 150: query processing execution unit

Claims (12)

Node number that sets the node number including the draw number and the minimum path length number for each of the plurality of nodes defined by resource / property / property values in the RDF document and arranged in a looped tree structure (loop tree structure). A setting unit, wherein the minimum path length number has the same length as the draw number and includes a minimum path length to each of at least one node of at least one node represented by the dew number;
A node group forming unit for forming n node groups corresponding to each of the n keywords and including one or more of the nodes as member nodes based on n keywords input from a user;
A node set forming unit which selects one member node from each of the n node groups using the node number to form m node sets including n member nodes;
For each of the m node sets, a minimum path length between a member node of a first node group and a member node of a last node group included in the node set is calculated, and the calculated minimum path length is set for each of the m node sets. A node set value setting unit set to be; And
A query processing execution unit that performs SPARQL query processing using the minimum set value among the set values of the m node sets, the member node of the first node group and the member node of the last node group in the node set having the minimum set value.
Apparatus for performing SPARQL query processing for keyword search comprising a. The method of claim 1,
The node group forming unit
And a node (j) which is an integer of 2 or more and n or less among the plurality of nodes, including a node including an attribute value as a member node of the j-th node group. The method of claim 1,
The minimum path length number is comprised of an array of zero or one or more numbers,
A number other than 0 of k (which is an integer of 1 or more) included in the minimum path length number for any one of the plurality of nodes is different from the first number included in the dway number for the one of the nodes. SPQRQL query processing apparatus for a keyword search, characterized in that the minimum path length between the node represented by the k-th number and any one of the nodes. The method of claim 3,
The node set forming unit
Among the one or more member nodes in the j-th node group, the i-th node set includes a member node having a minimum path length that is the minimum with a member node of the j-th node group included in the i-th node set. SPARQL query processing for the keyword search, characterized in that the selection as a member node of the j-th node group included in. The method of claim 4, wherein
The node set forming unit
First of all, using the minimum path length number, a minimum path length between any one member node in the j-th node group and a member node of the j-th node group included in the i-th node set is calculated.
If the minimum path length between the one of the member nodes and the member node of the j-1th node group included in the i-th node set cannot be calculated using the minimum path length number, the dewway number is used. And calculating a minimum path length between the any one member node and the member nodes of the j-1th node group included in the i-th node set. The method of claim 4, wherein
The node set forming unit
Align one or more member nodes in the j-th node group according to the minimum path length to the node forming the root node of the loop tree using the node number, and in the sorted j-th node group SPARQL query processing for keyword searching by selecting a member node having a minimum path length with the j-1 th member node included in the i th node set by applying a binary search technique to at least one member node. Perform device. The method of claim 6,
The node set forming unit
A minimum path length between any one member node and the root node in the j-th node group is first calculated using the minimum path length number,
If the minimum path length between the any one member node and the root node cannot be calculated using the minimum path length number, the minimum between the any one member node and the root node is used using the dewway number. SPARQL query processing for the keyword search, characterized in that for calculating the path length. The method of claim 3,
The node set value setting unit
Setting at least one reference node having at least some of a common part of a node number of a member node of the first node group and a part number of a member node of the last node group as the node number for each node set,
Calculate a first minimum path length between the member node of the first node group and each of the at least one reference node and a second minimum path length between the member node of the last node group and each of the at least one reference node,
The minimum value of the sum of the first minimum path length and the second minimum path length corresponding to each other is calculated as a minimum path length between the member node of the first node group and the member node of the last node group. SPARQL query processing device for searching. The method of claim 8,
The number of the at least one reference node is
The number of the last node and the number of the last node starting from the position corresponding to the last digit of the common part of the minimum number of path length numbers for the member nodes of the first node group and the position where the number of 0 is first arranged; Among the minimum path length numbers for the member nodes of the group, the dway number corresponds to the smaller value among the number of numbers starting from the position corresponding to the last digit of the common part and up to the position where the number of zero is first arranged. Apparatus for performing SPARQL query processing for keyword retrieval. The method of claim 1,
The number of the m node sets is equal to the number of member nodes included in the first node group, and the member nodes of the first node group included in the m node sets are different from each other. Query processing device. The method of claim 10,
And wherein the first node group is a node group having the minimum number of member nodes among the n node groups. Setting a node number including a way number and a minimum path length number for each of a plurality of nodes defined by resource / property / property values in the RDF document and arranged in a looped tree structure (loop tree structure)- The minimum path length number has a length equal to the dway number and includes a minimum path length to each of one or more nodes of at least one node represented by the dway number;
Forming an n node group corresponding to each of the n keywords and including one or more of the nodes as member nodes based on n keywords input from a user;
Selecting one member node from each of the n node groups using the node number to form a set of m nodes (which are integers of 1 or more) including n member nodes;
For each of the m node sets, a minimum path length between a member node of a first node group and a member node of a last node group included in the node set is calculated, and the calculated minimum path length is set for each of the m node sets. Setting to; And
Performing SPARQL query processing using the minimum set value among the set values of the m node sets, the member node of the first node group and the member node of the last node group in the node set having the minimum set value.
SPARQL query processing for the keyword search, characterized in that it comprises a.

Images