Runtime Data Retrieval via Interpreted Scripting and XML

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing web-based application programs are inflexible and costly due to the need for recoding when switching databases or accessing different data sources, leading to performance issues from frequent database connection openings and closings, and difficulty in retrieving dynamic data at runtime.

Innovation Solution

A system and method that uses an interpreted scripting language, leveraging Java and XML technologies, to decouple data retrieval from the underlying application by creating data definition documents with tags that are processed by a script interpreting engine and data lookup engine, allowing dynamic data access without requiring code changes, using reflection mechanisms to populate data objects.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If data access is coded at a low level using specific SQL dialects for specific databases, then data retrieval can be performed, but the application becomes inflexible and requires recoding when switching databases

Engineering Contradiction:
Improvedatabase compatibilityVSAvoidapplication recoding requirement
Core Design Contradiction:
Adaptability or versatilityVSEase of manufacture

Solution Approach 1:

The patent introduces an intermediary layer consisting of data definition documents (DDDs) and an interpretation engine that sits between the application code and the database. The DDDs contain platform-independent data element definitions with tags that map to specific database fields, allowing the application to access data through a standardized interface regardless of the underlying database type. This mediator layer translates generic data access requests into database-specific operations, eliminating the need for recoding when switching databases.

Inventive Principle:
Principle #24Intermediary (Mediator)

Solution Approach 2:

The patent segments the data access functionality into separate, reusable components. Data element accessors are divided into tagged data element definitions in DDDs that can be independently configured for different databases. The interpretation engine processes these segmented definitions dynamically, allowing each data element to be mapped to different database fields based on the target database without modifying the application code.

Inventive Principle:
Principle #1Segmentation

2Productivity

If database connections are opened and closed for each data access operation in CGI programs, then data can be retrieved, but performance significantly decreases due to the expensive connection operations

Engineering Contradiction:
Improvedata retrieval speedVSAvoidconnection opening and closing time
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

The patent implements preliminary action by establishing and maintaining persistent database connections in the interpretation engine before data access operations are needed. The connection management is performed in advance and maintained throughout the application's runtime, so that subsequent data retrieval operations can proceed without the overhead of opening and closing connections. This preliminary setup eliminates the repeated connection establishment cost for each data access operation.

Inventive Principle:
Principle #10Preliminary action

3Adaptability or versatility

If the interpreter has to interpret the data element accessor each time a new type of data source is accessed, then data can be retrieved, but it becomes difficult to keep the application running continuously

Engineering Contradiction:
Improvedata source flexibilityVSAvoidapplication continuous operation capability
Core Design Contradiction:
Adaptability or versatilityVSProductivity

Solution Approach 1:

The patent implements dynamics by allowing the interpretation engine to dynamically load and parse data definition documents at runtime based on the requested data source. Rather than requiring full re-interpretation of accessors for each new data source, the engine dynamically retrieves the appropriate DDD, parses only the necessary tagged data element definitions, and caches the results for rapid access. This dynamic approach maintains adaptability to different data sources while minimizing the performance overhead.

Inventive Principle:
Principle #15Dynamics

4Reliability

If code changes are required to access data from different data sources, then data retrieval can be performed, but the application loses reusability and becomes expensive to maintain

Engineering Contradiction:
Improvedata access accuracyVSAvoidapplication reusability
Core Design Contradiction:
ReliabilityVSAdaptability or versatility

Solution Approach 1:

The patent implements universality by creating a platform-independent data access framework where a single application codebase can access multiple types of data sources through standardized tagged data element definitions in DDDs. The interpretation engine provides multi-functional capability to interpret and execute data access operations against different database types and data sources using the same generic syntax. This universal interface allows the application to be reused across different data sources without modification, while maintaining reliable and accurate data access through the standardized tagging system.

Inventive Principle:
Principle #6Universality (Multi-functionality)

Data Source

PatentUS7861232B2Systems, methods and computer program products for retrieving and parsing data at runtime
Publication Date: 2010.12.28 TLV CO LTD
  • US7861232B2 patent drawing
  • US7861232B2 patent drawing
  • US7861232B2 patent drawing

AI summary

Disclosed is a method, system and computer product for retrieving and parsing dynamic data at runtime by use of an interpreted language script that utilize Java and XML technologies. The interpreted scripting language uses a set of proxies, introspection and configuration to access and retrieve data elements that are in existence within underlying applications but not immediately available to the interpreter.