WO2014098559A1 - A method of accelerated sparql query processing - Google Patents

A method of accelerated sparql query processing Download PDF

Info

Publication number
WO2014098559A1
WO2014098559A1 PCT/MY2013/000246 MY2013000246W WO2014098559A1 WO 2014098559 A1 WO2014098559 A1 WO 2014098559A1 MY 2013000246 W MY2013000246 W MY 2013000246W WO 2014098559 A1 WO2014098559 A1 WO 2014098559A1
Authority
WO
WIPO (PCT)
Prior art keywords
statements
output
variables
variable
statement
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Ceased
Application number
PCT/MY2013/000246
Other languages
French (fr)
Inventor
Poh Kit CHONG
Ettikan Kandasamy A/L KARUPPIAH
Keh Kok YONG
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Mimos Bhd
Original Assignee
Mimos Bhd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Mimos Bhd filed Critical Mimos Bhd
Publication of WO2014098559A1 publication Critical patent/WO2014098559A1/en
Anticipated expiration legal-status Critical
Ceased legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24—Querying
    • G06F16/245—Query processing
    • G06F16/2453—Query optimisation
    • G06F16/24534—Query rewriting; Transformation
    • G06F16/24539—Query rewriting; Transformation using cached or materialised query results
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24—Querying
    • G06F16/245—Query processing
    • G06F16/2453—Query optimisation
    • G06F16/24534—Query rewriting; Transformation
    • G06F16/24542—Plan optimisation
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24—Querying
    • G06F16/245—Query processing
    • G06F16/24569—Query processing with adaptation to specific hardware, e.g. adapted for using GPUs or SSDs

Definitions

  • the invention relates to a method of accelerated SPARQL query processing.
  • SPARQL queries are typically translated into multiple SQL queries by a semantics engine so they can be sent to an SQL database in order to retrieve the data in RDF format.
  • this can lead to highly inefficient behaviour due to inefficient scheduling or collisions, in that the server can timeout if there are too many queries to process.
  • the prior art method is not suitable for use in massively parallel computational accelerators such as GPGPUs.
  • An aim of the invention is to provide a method of SPARQL query processing which overcomes one or more of the above issues.
  • the output variables for the SPARQL query are identified and the corresponding statements are mapped to a binary form. Typically the statements are classified based on the number of variables.
  • the statements are ordered from those with the least variables to those with the most variables. Typically a previously unselected statement is selected as a start point.
  • the method includes a matching process where each variable in the statement that is not the final desired output variable is matched to another variable that uses the variable as an input, until the final output variable is reached wherein the statements' order is recorded as an ordered lists. Typically the matching process is repeated until all combinations have been selected.
  • the ordered lists are grouped according to the final output variables.
  • the ordered lists are merged at common nodes to form trees with each output variable as a root node.
  • the trees of different output variables are merged to obtain the relationship between the output variables
  • closest paths are found between all the output variables to determine intersection positions where temporary tables need to be created and stored to enable relationship formation between the output variables at the end of the search.
  • the relationship between the output variables is defined as a relationship tree wherein one or more leaf nodes are at the top of the tree opposite a root node.
  • unprocessed leaf nodes in the relationship tree are selected and the queries therefrom are used to perform a parallel search via a computation acceleration device and generate intermediate results.
  • the computation acceleration device includes a GPGPU.
  • the intermediate results from each node are recursively used as inputs to other nodes along the path from the leaf to the root until the root or an intersection before the root node is reached.
  • the intermediate results from the intersection points up to the root nodes are retained and the search is repeated until all leaf nodes have been processed.
  • the intermediate result tables from the intersection points up to the root nodes are logically combined by parallel matching the inputs and outputs for all the queries.
  • results matching the output variables from the tables are extracted and returned to the user.
  • a system for processing SPARQL queries comprising:
  • a Statement Table Mapper Unit for mapping the statements to a binary form
  • a Statement Classifier Unit for classifying the statements so as to form linked nodes for searching
  • Query Sorting Unit for sorting the statements based on the number of variables
  • Query Flow Linking Unit for linking outputs from the statements to inputs of other statements
  • a Common Variable Merger Unit that for forming a tree from related linked lists; a Parallelized Query Execution Engine for executing searches in parallel on leaf nodes within the tree; and a Table Matching and Output Engine for matching the results of the searches, in the form of temporary tables of results, to form a final matched output.
  • Figure 1 is a schematic view of the system for SPARQL query processing according to an embodiment of the invention.
  • Figure 2 is a schematic view of the Output Identification & Statement Classification Engine.
  • Figure 3 illustrates the Query Logics Reordering Engine: (a) in schematic view; (b) as a process flow; and (c) with an example query.
  • Figure 4 illustrates the Relationship Formation Engine: (a) in schematic view; (b) with an example of two ordered lists being merged in a relationship tree.
  • Figure 5 illustrates the Parallelized Query Execution Engine: (a) in schematic view; (b) with an example of searching at each node level being done in parallel.
  • Figure 6 is a schematic view of the Table Matching and Output Engine.
  • the SPARQL query is initially processed by the CPU 102 before being parallel processed by a hardware accelerator such as a GPGPU 104.
  • the SPARQL query is processed by an Output Identification & Statement Classification Engine 106 comprising a Statement Parser 108 for processing a SPARQL statement to a form easily used for parallel searching, a Statement Table Mapper Unit 1 10 for mapping the statements to a binary number, and a Statement Classifier Unit 1 12 for classifying the statements so as to form linked nodes for searching.
  • the statements are passed to a Query Logics Reordering Engine 1 14 comprising a Query Sorting Unit 1 16 for differentiating the queries based on the number of variables and a Query Flow Linking Unit 1 18 for linking outputs from statements to inputs of other statements.
  • a Relationship Formation Engine 120 comprising a Common Output Identifier Unit 122 for identifying linked list of nodes with common output variables, and a Common Variable Merger Unit 124 for forming a tree from related linked lists.
  • a Parallelized Query Execution Engine 126 for executing searches in parallel, and a Table Matching and Output Engine 128 for matching temporary intermediate output tables to form a final matched output.
  • the Output Identification & Statement Classification Engine is illustrated in more detail, wherein output variables for the SPARQL query are identified 201.
  • the corresponding SPARQL query statements are then mapped 202 to a binary form with 0 representing a pattern and 1 representing a variable and each bit corresponding to a respective subject, predicate, and object.
  • the statements are then classified 203 based on the number of variables (' l 's) in them.
  • the Query Logics Reordering Engine is illustrated in more detail, wherein a previously unselected statement is selected 301 as a start point and the statements are ordered from those with the least variables to those with the most.
  • Each variable in the statement that is not the final desired output variable is matched 302 to another variable that uses the variable as an input, and this is repeated 303 until the final output variable is reached wherein the statements' order is recorded as a list. This process is repeated 304 until all combinations have been selected.
  • Figure 3b illustrates the process flow through the Query Logics Reordering Engine, starting with a check 306 for unselected statements. If found, the statement with the lowest variables is selected 308 and checked 310 for multiple outputs. If multiple outputs are found the point of diversion and untraversed path is marked 312.
  • the statement is then checked 314 for final output variable. If present, a linked list is created 316, with the first node representing the first statement and the last node representing the final statement. If a check 318 for any diversion points being untraversed is positive, return 320 to the nearest untraversed point.
  • Figure 3c illustrates an example of statements being ordered and recorded as lists. For example, the query below:
  • the Relationship Formation Engine is illustrated in more detail, wherein the ordered lists are grouped 401 according to the final output variables, the ordered lists (Listl and List2) are merged 402 at common nodes (in this case the node where the variable is '?subject') to form trees with each output variable as a root node, and the trees of different output variables are merged 403 to obtain the relationship between the output variables.
  • the closest paths are then found 404 between all the output variables to determine intersection positions where temporary tables need to be created and stored to enable relationship formation between the output variables at the end of the search.
  • FIG. 5a-b the Parallelized Query Execution Engine is illustrated in more detail wherein unprocessed leaf nodes in the relationship tree (the leaf nodes being at the top of the tree opposite the root) are selected 501 and the queries therefrom are used to perform a parallel search via the computation acceleration device (GPGPU).
  • the intermediate results from each node are recursively used 502 as inputs to other nodes along the path from the leaf to the root until the root or an intersection before the root node is reached.
  • the parallel search result tables from the intersection points up to the root nodes are kept 503 and the process is repeated until all leaf nodes have been processed.
  • Table Matching and Output Engine is illustrated in more detail wherein the intermediate result tables from the intersection points up to the root nodes are logically combined 601 by parallel matching 602 the inputs and outputs for all the queries. Results matching the output variables from the tables are extracted and returned 603 to the CPU for display.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Computational Linguistics (AREA)
  • Data Mining & Analysis (AREA)
  • Databases & Information Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Operations Research (AREA)
  • Information Retrieval, Db Structures And Fs Structures Therefor (AREA)

Abstract

A method of SPARQL query processing comprising the steps of parsing a SPARQL query to form one or more statement lists, expanding the statement lists into temporary tables of results, and merging the temporary tables of results at their intersections to generate output variable results.

Description

A METHOD OF ACCELERATED SPARQL QUERY PROCESSING
Field of Invention
The invention relates to a method of accelerated SPARQL query processing.
Background
According to the prior art, SPARQL queries are typically translated into multiple SQL queries by a semantics engine so they can be sent to an SQL database in order to retrieve the data in RDF format. However, this can lead to highly inefficient behaviour due to inefficient scheduling or collisions, in that the server can timeout if there are too many queries to process.
In addition, the prior art method is not suitable for use in massively parallel computational accelerators such as GPGPUs.
An aim of the invention is to provide a method of SPARQL query processing which overcomes one or more of the above issues.
Summary of Invention In an aspect of the invention, there is provided a method of SPARQL query processing comprising the following steps:
parsing a SPARQL query to form one or more statement lists;
expanding the statement lists into temporary tables of results; and
merging the temporary tables of results at their intersections to generate output variable results.
In one embodiment the output variables for the SPARQL query are identified and the corresponding statements are mapped to a binary form. Typically the statements are classified based on the number of variables.
In one embodiment the statements are ordered from those with the least variables to those with the most variables. Typically a previously unselected statement is selected as a start point.
In one embodiment the method includes a matching process where each variable in the statement that is not the final desired output variable is matched to another variable that uses the variable as an input, until the final output variable is reached wherein the statements' order is recorded as an ordered lists. Typically the matching process is repeated until all combinations have been selected.
In one embodiment the ordered lists are grouped according to the final output variables. Typically the ordered lists are merged at common nodes to form trees with each output variable as a root node. Typically the trees of different output variables are merged to obtain the relationship between the output variables
In one embodiment closest paths are found between all the output variables to determine intersection positions where temporary tables need to be created and stored to enable relationship formation between the output variables at the end of the search.
In one embodiment the relationship between the output variables is defined as a relationship tree wherein one or more leaf nodes are at the top of the tree opposite a root node.
In one embodiment, unprocessed leaf nodes in the relationship tree are selected and the queries therefrom are used to perform a parallel search via a computation acceleration device and generate intermediate results. Typically the computation acceleration device includes a GPGPU.
In one embodiment the intermediate results from each node are recursively used as inputs to other nodes along the path from the leaf to the root until the root or an intersection before the root node is reached.
In one embodiment the intermediate results from the intersection points up to the root nodes are retained and the search is repeated until all leaf nodes have been processed. In one embodiment the intermediate result tables from the intersection points up to the root nodes are logically combined by parallel matching the inputs and outputs for all the queries.
In one embodiment the results matching the output variables from the tables are extracted and returned to the user.
In a further aspect of the invention there is provided a system for processing SPARQL queries, comprising:
a Statement Parser for processing a SPARQL query into statements;
a Statement Table Mapper Unit for mapping the statements to a binary form; a Statement Classifier Unit for classifying the statements so as to form linked nodes for searching;
a Query Sorting Unit for sorting the statements based on the number of variables;
a Query Flow Linking Unit for linking outputs from the statements to inputs of other statements;
a Common Output Identifier Unit for identifying linked lists of statements with common output variables;
a Common Variable Merger Unit that for forming a tree from related linked lists; a Parallelized Query Execution Engine for executing searches in parallel on leaf nodes within the tree; and a Table Matching and Output Engine for matching the results of the searches, in the form of temporary tables of results, to form a final matched output.
Brief Description of Drawings
It will be convenient to further describe the present invention with respect to the accompanying drawings that illustrate possible arrangements of the invention. Other arrangements of the invention are possible, and consequently the particularity of the accompanying drawings is not to be understood as superseding the generality of the preceding description of the invention.
Figure 1 is a schematic view of the system for SPARQL query processing according to an embodiment of the invention.
Figure 2 is a schematic view of the Output Identification & Statement Classification Engine.
Figure 3 illustrates the Query Logics Reordering Engine: (a) in schematic view; (b) as a process flow; and (c) with an example query.
Figure 4 illustrates the Relationship Formation Engine: (a) in schematic view; (b) with an example of two ordered lists being merged in a relationship tree. Figure 5 illustrates the Parallelized Query Execution Engine: (a) in schematic view; (b) with an example of searching at each node level being done in parallel. Figure 6 is a schematic view of the Table Matching and Output Engine.
Detailed Description With reference to Figure 1 , there is illustrated a summary of the system for accelerating SPARQL query processing according to an embodiment of the invention.
The SPARQL query is initially processed by the CPU 102 before being parallel processed by a hardware accelerator such as a GPGPU 104.
In the CPU the SPARQL query is processed by an Output Identification & Statement Classification Engine 106 comprising a Statement Parser 108 for processing a SPARQL statement to a form easily used for parallel searching, a Statement Table Mapper Unit 1 10 for mapping the statements to a binary number, and a Statement Classifier Unit 1 12 for classifying the statements so as to form linked nodes for searching. The statements are passed to a Query Logics Reordering Engine 1 14 comprising a Query Sorting Unit 1 16 for differentiating the queries based on the number of variables and a Query Flow Linking Unit 1 18 for linking outputs from statements to inputs of other statements.
The statements, now ordered into lists, are then passed to a Relationship Formation Engine 120 comprising a Common Output Identifier Unit 122 for identifying linked list of nodes with common output variables, and a Common Variable Merger Unit 124 for forming a tree from related linked lists.
In the GPGPU 104, there is provided a Parallelized Query Execution Engine 126 for executing searches in parallel, and a Table Matching and Output Engine 128 for matching temporary intermediate output tables to form a final matched output. With reference to Figure 2, the Output Identification & Statement Classification Engine is illustrated in more detail, wherein output variables for the SPARQL query are identified 201. The corresponding SPARQL query statements are then mapped 202 to a binary form with 0 representing a pattern and 1 representing a variable and each bit corresponding to a respective subject, predicate, and object. The statements are then classified 203 based on the number of variables (' l 's) in them.
With regard to Figure 3a, the Query Logics Reordering Engine is illustrated in more detail, wherein a previously unselected statement is selected 301 as a start point and the statements are ordered from those with the least variables to those with the most. Each variable in the statement that is not the final desired output variable is matched 302 to another variable that uses the variable as an input, and this is repeated 303 until the final output variable is reached wherein the statements' order is recorded as a list. This process is repeated 304 until all combinations have been selected.
Figure 3b illustrates the process flow through the Query Logics Reordering Engine, starting with a check 306 for unselected statements. If found, the statement with the lowest variables is selected 308 and checked 310 for multiple outputs. If multiple outputs are found the point of diversion and untraversed path is marked 312.
The statement is then checked 314 for final output variable. If present, a linked list is created 316, with the first node representing the first statement and the last node representing the final statement. If a check 318 for any diversion points being untraversed is positive, return 320 to the nearest untraversed point.
If the check 314 shows no final output variable in the statement, then the statement with intermediate output variable as input is found 322 and the process loops until the final output variable is reached.
The procedure is repeated until all combinations have been selected
Figure 3c illustrates an example of statements being ordered and recorded as lists. For example, the query below:
SELECT ?subject ?predicate ?object WHERE {
?major rdfs:subClassOf mohr:MASCO.
?subMinor rdfs:subClassOf ?minor. ?minor rdfs:subClassOf ?subMajor. ?subMajor rdfs:subClassOf ?major. ?subject rdf:type ?subMinor.
?subject mohr:hasName 'Lawyer'@en.
?subject ?predicate ?object.
} becomes:
Listl
?major rdfs:subClassOf mohr:MASCO. ?subMajor rdfs:subClassOf ?major. ?minor rdfs:subClassOf ?subMajor. ?subMinor rdfs:subClassOf ?minor. ?subject rdf:type ?subMinor.
?subject ?predicate ?object.
List2
?subject mohr:hasName 'Lawyer'@en.
?subject ?predicate ?object.
With respect to Figures 4a-b the Relationship Formation Engine is illustrated in more detail, wherein the ordered lists are grouped 401 according to the final output variables, the ordered lists (Listl and List2) are merged 402 at common nodes (in this case the node where the variable is '?subject') to form trees with each output variable as a root node, and the trees of different output variables are merged 403 to obtain the relationship between the output variables. The closest paths are then found 404 between all the output variables to determine intersection positions where temporary tables need to be created and stored to enable relationship formation between the output variables at the end of the search.
With regard to Figures 5a-b the Parallelized Query Execution Engine is illustrated in more detail wherein unprocessed leaf nodes in the relationship tree (the leaf nodes being at the top of the tree opposite the root) are selected 501 and the queries therefrom are used to perform a parallel search via the computation acceleration device (GPGPU). The intermediate results from each node are recursively used 502 as inputs to other nodes along the path from the leaf to the root until the root or an intersection before the root node is reached. The parallel search result tables from the intersection points up to the root nodes are kept 503 and the process is repeated until all leaf nodes have been processed. With regard to Figure 6 Table Matching and Output Engine is illustrated in more detail wherein the intermediate result tables from the intersection points up to the root nodes are logically combined 601 by parallel matching 602 the inputs and outputs for all the queries. Results matching the output variables from the tables are extracted and returned 603 to the CPU for display.
It will be appreciated by persons skilled in the art that the present invention may also include further additional modifications made to the device which does not affect the overall functioning of the device.

Claims

1. A method of SPARQL query processing comprising the following steps:
parsing a SPARQL query to form one or more statement lists;
expanding the statement lists into temporary tables of results; and merging the temporary tables of results at their intersections to generate output variable results.
2. A method according to claim 1 wherein the output variables for the SPARQL query are identified and the corresponding statements are mapped to a binary form and classified based on the number of variables therein.
3. A method according to claim 2 wherein the statements are ordered from those with the least variables to those with the most variables.
4. A method according to claim 2 or 3 including a matching process where each variable in the statement that is not the final desired output variable is matched to another variable that uses the variable as an input, until the final output variable is reached wherein the statements' order is recorded as an ordered lists.
A method according to claim 4 wherein the ordered lists are grouped according to the final output variables, and merged at common nodes to form trees with each output variable as a root node.
A method according to claim 5 wherein the trees of different output variables are merged to obtain the relationship between the output variables
A method according to claim 6 wherein the closest paths are found between all the output variables to determine intersection positions where the temporary tables need to be created and stored to enable relationship formation between the output variables at the end of the search.
A method according to claim 7 wherein the relationship between the output variables is defined as a relationship tree in which one or more leaf nodes are at the top of the tree opposite a root node.
A method according to claim 8 wherein unprocessed leaf nodes in the relationship tree are selected and the queries therefrom are used to perform a parallel search via a computation acceleration device to generate the temporary tables of results.
10. A method according to claim 9 wherein the temporary tables from each node are recursively used as inputs to other nodes along the path from the leaf to the root until the root or an intersection before the root node is reached.
A method according to claim 10 wherein the temporary tables from the intersection points up to the root nodes are retained and the search is repeated until all leaf nodes have been processed.
A method according to claim 1 1 wherein the temporary tables from the intersection points up to the root nodes are logically combined by parallel matching the inputs and outputs for all the queries.
A method according to claim 12 wherein the results matching the output variables from the temporary tables are extracted and returned to a user.
A system for processing SPARQL queries, comprising:
a Statement Parser for processing a SPARQL query into statements; a Statement Table Mapper Unit for mapping the statements to a binary form;
a Statement Classifier Unit for classifying the statements so as to form linked nodes for searching;
a Query Sorting Unit for sorting the statements based on the number of variables; a Query Flow Linking Unit for linking outputs from the statements to inputs of other statements;
a Common Output Identifier Unit for identifying linked lists of statements with common output variables;
a Common Variable Merger Unit that for forming a tree from related linked lists;
a Parallelized Query Execution Engine for executing searches in parallel on leaf nodes within the tree; and
a Table Matching and Output Engine for matching the results of the searches, in the form of temporary tables of results, to form a final matched output.
PCT/MY2013/000246 2012-12-17 2013-12-10 A method of accelerated sparql query processing Ceased WO2014098559A1 (en)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
MYPI2012005468A MY188923A (en) 2012-12-17 2012-12-17 A method of accelerated sparql query processing
MYPI2012005468 2012-12-17

Publications (1)

Publication Number Publication Date
WO2014098559A1 true WO2014098559A1 (en) 2014-06-26

Family

ID=50184969

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/MY2013/000246 Ceased WO2014098559A1 (en) 2012-12-17 2013-12-10 A method of accelerated sparql query processing

Country Status (2)

Country Link
MY (1) MY188923A (en)
WO (1) WO2014098559A1 (en)

Non-Patent Citations (5)

* Cited by examiner, † Cited by third party
Title
"CHAPTER 19: Algorithms for Query Processing and Optimization ED - Ramez Elmasri; Shamkant B Navathe (eds)", 1 January 2011, FUNDAMENTALS OF DATABASE SYSTEMS (SIXTH EDITION), ADDISON-WESLEY, PAGE(S) 679 - 725, ISBN: 978-0-13-608620-8, XP009171423 *
ANONYMOUS: "General-purpose computing on graphics processing units - Wikipedia, the free encyclopedia", 29 November 2012 (2012-11-29), XP055117346, Retrieved from the Internet <URL:http://en.wikipedia.org/w/index.php?title=General-purpose_computing_on_graphics_processing_units&oldid=525538885> [retrieved on 20140512] *
JÜRG SENN: "Parallel Join Processing on Graphics Processors for the Resource Description Framework", 23RD INTERNATIONAL CONFERENCE ON ARCHITECTURE OF COMPUTING SYSTEMS (ARCS), 23 February 2010 (2010-02-23), XP055116829 *
KATJA HOSE ET AL: "Database Foundations for Scalable RDF Processing", 23 August 2011, REASONING WEB. SEMANTIC TECHNOLOGIES FOR THE WEB OF DATA, SPRINGER BERLIN HEIDELBERG, BERLIN, HEIDELBERG, PAGE(S) 202 - 249, ISBN: 978-3-642-23031-8, XP019161804 *
OLAF HARTIG ET AL: "The SPARQL Query Graph Model for Query Optimization", 3 June 2007, THE SEMANTIC WEB: RESEARCH AND APPLICATIONS; [LECTURE NOTES IN COMPUTER SCIENCE;;LNCS], SPRINGER BERLIN HEIDELBERG, BERLIN, HEIDELBERG, PAGE(S) 564 - 578, ISBN: 978-3-540-72666-1, XP019094639 *

Also Published As

Publication number Publication date
MY188923A (en) 2022-01-13

Similar Documents

Publication Publication Date Title
Zhang et al. EAGRE: Towards scalable I/O efficient SPARQL query evaluation on the cloud
US20180067987A1 (en) Database capable of integrated query processing and data processing method thereof
de Freitas et al. Conceptual mappings to convert relational into NoSQL databases
CN114218400A (en) Semantic-based data lake query system and method
US9372938B2 (en) Augmenting queries when searching a semantic database
CN103886011B (en) Social-relation network creation and retrieval system and method based on index files
CN106874426B (en) A Real-time Keyword Search Method for RDF Streaming Data Based on Storm
CN105740344A (en) Sql statement combination method and system independent of database
CN103310011A (en) Analytical method for data query under cluster database system environment
CN109325029A (en) RDF data storage and query method based on sparse matrix
CN120560649A (en) A method, device and medium for generating SQL statements based on natural language
CN116383247B (en) Large-scale graph data efficient query method
CN113360404A (en) Method and device for comparing metadata of database
CN119760113B (en) A Legal Concept Interpretation Method Based on Multi-Perspective Clustering and Hybrid Retrieval
Guo et al. Distributed processing of regular path queries in RDF graphs
CN106055690A (en) Method for carrying out rapid retrieval and acquiring data features on basis of attribute matching
JPH10187739A (en) Information retrieving device
US9959295B1 (en) S-expression based computation of lineage and change impact analysis
Slavov et al. Fast processing of SPARQL queries on RDF quadruples
WO2014098559A1 (en) A method of accelerated sparql query processing
Makpisit SPARQL query optimizations for GPU RDF stores
Ghanbarpour et al. Efficient keyword search over graph-structured data based on minimal covered r-cliques
Zheng et al. User preference-based data partitioning top-k skyline query processing algorithm
Wolff et al. An Extensible Framework for Query Optimization on TripleT-based RDF Stores.
Katib et al. A Tool for Efficiently Processing SPARQL Queries on RDF Quads.

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 13831980

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 13831980

Country of ref document: EP

Kind code of ref document: A1