In-Memory Denormalized RDF Data Structure for Database Query Optimization
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The high computational costs associated with performing join operations on normalized RDF data in relational database systems, particularly when dealing with large volumes of data, hinder efficient generation of denormalized query results in semantic web applications.
Innovation Solution
The implementation of an in-memory table structure that includes both normalized and denormalized columns, allowing queries to be processed without the need for join operations by pre-populating virtual columns with denormalized values from a dictionary table, thereby reducing computational expenses.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Quantity of substance
If normalized RDF data is stored in relational database tables with separate tables for subjects, predicates, and objects, then data storage space is saved and data integrity is improved, but the computational cost of performing join operations to retrieve denormalized results becomes very high
Solution Approach 1:
The patent applies preliminary action by pre-computing and storing denormalized RDF data in a denormalized cache table before queries are executed. When RDF data is inserted or updated in normalized form, the system proactively denormalizes it and stores both normalized and denormalized versions in the cache table. This preliminary preparation eliminates the need for expensive join operations during query execution, as the denormalized data is already available in ready-to-use format.
2Loss of information
If join operations are performed between normalized tables to generate denormalized query results, then complete RDF triple information is retrieved, but the computational expense increases significantly especially with large volumes of data
Solution Approach 1:
The patent merges normalized and denormalized RDF data into a single denormalized cache table that contains both forms of data representation. The cache table structure includes columns for normalized identifiers (subject_id, predicate_id, object_id) and their corresponding denormalized values (subject, predicate, object). This merging allows the system to maintain data integrity through normalized storage while providing efficient denormalized access paths, eliminating the need for runtime join operations between separate tables.
3Ease of manufacture
If normalization techniques are applied to RDF data storage, then data redundancy is removed and maintenance ease is improved, but the complexity of query operations increases due to required join operations
Solution Approach 1:
The patent introduces a denormalized cache table as an intermediary structure between normalized RDF data storage and query processing operations. This intermediary table serves as a bridge that contains pre-computed denormalized data, allowing queries to access complete RDF triple information without directly performing complex join operations on normalized tables. The cache table absorbs the complexity of join operations, presenting a simplified access interface to query processors while maintaining the benefits of normalized storage for data maintenance.
Data Source
AI summary
Systems for database query processors. In a method embodiment, processing commences upon receiving a first set of a plurality of database language queries that reference a normalized column in an RDF table and that also includes a JOIN clause that references both the normalized column in the RDF table and a corresponding lookup table (e.g., a denormalization dictionary) that contains both normalized RDF data and denormalized RDF data. An in-memory table is allocated and formatted to comprise virtual columns that correspond to denormalized RDF data. Virtual columns of the in-memory table are populated with denormalized RDF data. In case of receipt of a SPARQL query, the incoming query is first translated into non-SPARQL database statements which are in turn recoded into database language statements that use lookup functions to lookup the denormalized RDF data from the virtual columns of the in-memory table rather than by incurring expensive disk I/O operations.