Database Query Plan Node Identification

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Database query execution performance is degraded due to redundant processing of shared child nodes in query plans, resulting from duplicated access of shared operators during query execution.

Innovation Solution

A method is implemented to efficiently access shared operators in database query plans by traversing a query plan tree, uniquely numbering nodes to avoid duplicate processing of shared child nodes, using a global node identifier counter to differentiate visited and unvisited nodes.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If query plan tree is traversed without node identification, then all nodes are processed, but shared child nodes are processed multiple times causing redundant operations

Engineering Contradiction:
Improvequery execution performanceVSAvoidredundant processing
Core Design Contradiction:
ProductivityVSLoss of energy

Solution Approach 1:

The patent applies preliminary action by initializing node identifiers to a default value before traversal begins. This pre-setup allows the traversal algorithm to efficiently identify and skip already-processed shared child nodes during execution, preventing redundant processing without requiring complex runtime checks or data structures.

Inventive Principle:
Principle #10Preliminary action

2Reliability

If all nodes in query plan tree are traversed, then complete query plan is processed, but shared operators are accessed multiple times degrading performance

Engineering Contradiction:
Improvequery plan completenessVSAvoidquery execution speed
Core Design Contradiction:
ReliabilityVSProductivity

Solution Approach 1:

The patent implements feedback by using node identifiers that track whether a node has been visited during traversal. When the traversal algorithm encounters a node, it checks the identifier; if already set (indicating previous visit), it skips processing. This feedback mechanism ensures complete query plan processing while eliminating redundant operations on shared operators.

Inventive Principle:
Principle #23Feedback

3Adaptability or versatility

If shared child nodes are processed by multiple parent nodes, then each parent can access its children, but duplicate access occurs reducing efficiency

Engineering Contradiction:
Improveparent node access flexibilityVSAvoidduplicate processing time
Core Design Contradiction:
Adaptability or versatilityVSLoss of time

Solution Approach 1:

The patent applies copying by creating unique node identifier values that are assigned to each node during traversal. Instead of allowing multiple parent nodes to independently process shared child nodes (which would cause duplicate access), the system copies the identifier information and uses it to redirect subsequent accesses, ensuring each node is processed exactly once while maintaining the flexible parent-child relationships required by different query plans.

Inventive Principle:
Principle #26Copying

Data Source

PatentUS12135713B2Efficiently accessing shared operators in database query plans
Publication Date: 2024.11.05 SAP SE
  • US12135713B2 patent drawing
  • US12135713B2 patent drawing
  • US12135713B2 patent drawing

AI summary

The present disclosure involves systems, software, and computer implemented methods for efficiently accessing shared operators in database query plans. One example method includes identifying a query plan tree that represents a query plan for a database query. A node identifier of each node of the query plan tree is initialized to a default node identifier value and a global node identifier counter for the query plan tree is initialized. The query plan tree is traversed including determining whether a node identifier of a current node equals the default node identifier value. If the node identifier of the current node equals the default node identifier value, the current node is processed, the node identifier of the current node is set to a current value of the global node identifier counter, and the global node identifier counter is incremented. Otherwise processing of the current node is skipped.