Opaque Type Direct Loading via Dispatch Table
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current database systems are unable to efficiently store instances of opaque types using the direct path loading approach due to lack of information about the internal structure of these types, leading to performance issues and high memory consumption.
Innovation Solution
A program implementing the opaque type registers routines with a loader application, which consults a dispatch table to determine the structure and attributes, allowing the loader to create an array and stream data directly into the database without relying on the SQL engine.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If conventional path loading is used to store structured data, then the SQL engine can process the data, but performance deteriorates and memory consumption increases
Solution Approach 1:
The patent extracts the SQL engine processing step from the data loading path. Instead of routing all structured data through the SQL engine, the system directly inserts data into database tables using bulk insert operations, bypassing the SQL engine's row-by-row processing while maintaining data integrity through constraints and triggers.
Solution Approach 2:
The patent segments the data loading process into two distinct paths: conventional path loading for standard structured data types that require SQL engine processing, and direct path loading for opaque types that can be directly inserted. This segmentation allows each path to be optimized for its specific use case.
2Productivity
If direct path loading is used for structured data, then performance improves, but the system cannot handle opaque types without modifications
Solution Approach 1:
The patent creates a universal loader application that can handle both standard structured data types and opaque types through a single interface. The loader uses a dispatch table mechanism that automatically routes different data types to appropriate handling routines, making the system multi-functional without requiring separate loading mechanisms.
Solution Approach 2:
The patent introduces a dispatch table as an intermediary between the loader application and the data insertion process. The dispatch table stores type information and routing logic, allowing the loader to dynamically determine how to handle different data types including opaque types, without hardcoding specific handling logic for each type.
3Adaptability or versatility
If the loader application is modified to support new opaque types, then adaptability improves, but device complexity increases
Solution Approach 1:
The patent performs preliminary action by pre-defining type information in the dispatch table before the loading process begins. Type metadata including structure definitions and handling routines are registered in advance, allowing the loader to handle new opaque types without modification as long as the type information is registered in the dispatch table.
Solution Approach 2:
The patent makes the loader application dynamic by implementing a dispatch table that can be configured at runtime. The system can dynamically add, remove, or modify type handlers in the dispatch table without recompiling or reconfiguring the core loader application, enabling flexible adaptation to new opaque types.
Data Source
AI summary
Techniques and systems are disclosed for storing instances of an opaque type in a database according to a direct path loading approach. According to one aspect, an opaque type implementor registers, with a loader application, routines that the opaque type implementor implements. In response, the loader application associates the opaque type with the routines. The loader application reads data that comprises instances of the opaque type. The loader application determines which routines are associated with the opaque type. The loader application invokes the routines, which create an array for storing instances of the opaque type and populate the array with values specified in the data. The loader application converts the array into a data stream that conforms to the format of the database's data blocks. The loader application then streams the data to a database server, which writes the data directly into data blocks in the database.