Local Cache Query Execution Engine for Cloud Data Warehouses

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Modern businesses face challenges in efficiently manipulating and composing complex database queries, particularly when accessing large data sets stored in cloud-based data warehouses, as most users lack the skills to do so efficiently.

Innovation Solution

A query execution engine generates database queries using a state specification from a graphical user interface, searches a local cache for previous query results, determines if the current query can be generated using cached data, and creates the query result without accessing the cloud-based data warehouse, thereby reducing the need for remote data retrieval.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Speed

If database queries are executed by retrieving data directly from cloud-based data warehouse, then data accuracy is maintained, but query response time increases and system latency worsens

Engineering Contradiction:
Improvequery response timeVSAvoiddata accuracy
Core Design Contradiction:
SpeedVSReliability

Solution Approach 1:

The system performs preliminary actions by pre-computing and caching query results in a local database before they are actually needed. When a query is executed, the system first checks the local cache for pre-computed results, allowing fast retrieval without immediate access to the remote data warehouse. This preliminary computation and caching of data enables faster query responses while maintaining data accuracy through proper cache invalidation mechanisms.

Inventive Principle:
Principle #10Preliminary action

2Ease of operation

If complex database queries are constructed manually, then query specificity is improved, but user accessibility and ease of use deteriorate

Engineering Contradiction:
Improveuser accessibilityVSAvoidquery construction complexity
Core Design Contradiction:
Ease of operationVSDevice complexity

Solution Approach 1:

The system introduces an intermediary layer between the user and the complex database queries. A query translator or abstraction layer converts simple user-friendly queries into complex SQL statements automatically. This intermediary handles the complexity of query construction, allowing users to access data through simplified interfaces while the system manages the underlying complexity of translating these queries into executable database operations.

Inventive Principle:
Principle #24Intermediary (Mediator)

3Productivity

If local cache is used to store query results, then query servicing speed improves, but cache management complexity increases

Engineering Contradiction:
Improvequery servicing speedVSAvoidcache management complexity
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The cache management system performs self-service operations to reduce manual intervention and complexity. The system automatically handles cache invalidation, expiration, and updates based on predefined policies without requiring manual management. Cache invalidation is triggered automatically when source data changes, and the system self-regulates cache performance parameters, reducing the operational complexity of managing the cache while maintaining high query servicing speed.

Inventive Principle:
Principle #25Self-service

Data Source

PatentUS20230153301A1Evaluating stored query results
Publication Date: 2023.05.18 SIGMA COMPUTING INC
  • US20230153301A1 patent drawing
  • US20230153301A1 patent drawing
  • US20230153301A1 patent drawing

AI summary

Evaluating stored query results including generating a database query using a state specification of a graphical user interface, wherein the database query is composed to retrieve a current query result from a cloud-based data warehouse; searching a cache local to the query execution engine for the current query result, wherein the cache comprises a first previous query result from the cloud-based data warehouse; determining, based on the searching, that the current query result may be generated using the first previous query result from the cache; and creating the current query result using at least a portion of the first previous query result from the cache.