SPARQL Operator Graph Merging for Distributed RDF Queries
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for processing SPARQL queries over distributed RDF graphs face challenges in network chattiness due to intermediate results, particularly in cloud-based and partition-based approaches, and lack effective strategies for optimizing query execution without prior knowledge of data partitioning.
Innovation Solution
A method for generating a Directed Acyclic Graph (DAG) of operators by identifying groups of basic operators with shared subjects, predicates, or objects, and replacing them with equivalent operators, optimizing query execution by reducing communication costs and eliminating redundant operations in a distributed RDF graph environment.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If cloud-based approaches use MapReduce techniques for distributed RDF graph processing, then scalability is improved, but network chattiness increases due to intermediate results
Solution Approach 1:
The patent combines multiple basic operators of the first type that share the same subject and/or predicate and/or object into a single equivalent operator. This merging eliminates redundant operations and intermediate results, reducing network chattiness while maintaining the distributed processing capability for scalability.
Solution Approach 2:
The equivalent operator replaces multiple basic operators and performs multiple functions simultaneously. It can find RDF triples matching multiple basic graph patterns in a single operation, reducing the number of intermediate results and network communications required.
2Productivity
If partition-based approaches decompose SPARQL queries into subqueries over partitioned data, then query processing efficiency is improved, but the approach cannot enforce partitioning strategy due to lack of schemas in RDF
Solution Approach 1:
The patent segments the query processing by identifying groups of operators that can be merged. This segmentation allows the system to work with partitioned RDF data without requiring schema enforcement, as the operator merging is based on pattern matching rather than schema-based partitioning.
Solution Approach 2:
The patent changes the approach from schema-based partitioning to pattern-based operator merging. By changing the fundamental parameter from relying on RDF schemas to using basic graph pattern matching, the system achieves both query processing efficiency and adaptability to unknown partitioning strategies.
3Measurement precision
If basic operators are executed individually to find matching RDF triples, then query accuracy is maintained, but redundant operations increase and performance decreases
Solution Approach 1:
The patent merges multiple basic operators into equivalent operators that perform the same function in a single operation. This maintains query accuracy by preserving the semantic meaning of finding matching RDF triples while eliminating redundant operations to improve performance.
Solution Approach 2:
The patent discards redundant intermediate results that would be produced by executing basic operators individually. The equivalent operators directly produce the final results without generating unnecessary intermediate data, thereby improving performance while maintaining accuracy.
Data Source
AI summary
A computer-implemented method for generating by a query engine a graph of operators for a SPARQL query over an RDF graph. The method includes obtaining a graph of operators executable by the query engine, the graph comprising a plurality of basic operators, at least two of said operators being of a first type each configured to find RDF triples of the RDF graph that match a respective basic graph pattern. The method further comprises identifying a group of operators among the at least two basic operators of the graph which are of the first type. The respective basic graph patterns of the group of operators have same subject and/or predicate and/or object and the identified group of operators is replaced in the graph by an equivalent operator configured to find RDF triples of the RDF graph that match the respective basic graph patterns of the group of operators.