Incremental Testing of Embedded SQL Code
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing ETL process incurs high costs and delays due to the time-consuming process of iterative code changes, which require repeated compilation, installer building, and deployment in test environments before testing, especially when dealing with embedded SQL code within primary programming language applications.
Innovation Solution
A selective testing framework that incrementally constructs and tests embedded program code externally and independently of the host application, avoiding the overhead of compiling and deploying the primary code, allowing for efficient evaluation and rapid testing across different database systems.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If iterative code changes are made to the ETL application with embedded SQL code, then the application functionality can be improved and adapted, but the development cost and time increase due to repeated compilation, installer building, and deployment in test environments
Solution Approach 1:
The patent segments the testing process by separating embedded SQL code extraction and testing from the host application compilation and deployment. The SQL code is extracted, transformed into a standalone testable format, and tested independently before being integrated back into the application. This segmentation allows functional improvements without requiring full application recompilation and redeployment, thus reducing development time while maintaining adaptability.
Solution Approach 2:
The patent extracts the embedded SQL program code from the host application into a separate, independently testable format. This extraction enables the SQL code to be tested, validated, and modified separately from the main application, eliminating the need to recompile and redeploy the entire application for SQL code changes, thereby reducing development time and costs while preserving functionality.
2Reliability
If the entire application is compiled and deployed in test environments for testing embedded code changes, then comprehensive testing can be performed, but the process becomes expensive and time-consuming
Solution Approach 1:
The patent segments the testing process to test only the embedded SQL code separately from the host application. By extracting SQL code and transforming it into a standalone testable format, the system enables targeted testing that ensures reliability of SQL functionality without requiring full application deployment, thus improving development efficiency while maintaining testing completeness for SQL components.
Solution Approach 2:
The patent introduces an intermediary transformation process that converts extracted SQL code into a standalone executable format suitable for independent testing. This intermediary step allows comprehensive testing of SQL code logic and behavior without requiring the host application to be compiled and deployed, thereby maintaining testing reliability while significantly improving development efficiency.
3Manufacturing precision
If repeated compilation and deployment cycles are performed for testing, then code changes can be validated, but development costs increase and release timing is delayed
Solution Approach 1:
The patent segments the validation process to validate only the embedded SQL code separately from the host application. By extracting SQL code and testing it in isolation, the system achieves accurate code validation for SQL functionality without incurring the full costs of repeated application compilation and deployment, thus improving ease of manufacture while maintaining validation accuracy.
Solution Approach 2:
The patent creates a copy of the embedded SQL code in a standalone, testable format that replicates the original SQL functionality. This copy can be validated independently without affecting the host application, ensuring code validation accuracy while reducing development costs by eliminating the need for repeated full application compilation and deployment cycles.
4Stability of the object's composition
If the host application must be compiled and deployed to test embedded code, then integration context is preserved, but the testing process loses independence and efficiency
Solution Approach 1:
The patent segments the testing process to extract and test SQL code independently while preserving the integration context through separate validation steps. The SQL code is tested in isolation for efficiency and independence, then the results are integrated back into the host application context, maintaining stability of the overall system composition while improving ease of operation through independent testing.
Solution Approach 2:
The patent introduces an intermediary transformation and testing process that bridges the gap between independent SQL code testing and host application integration context. The intermediary process validates SQL code independently and then ensures proper integration with the host application, thereby achieving both testing independence and integration context stability.
Data Source
AI summary
An application can include program code in multiple programming languages. Typically, a primary or host application program code will include secondary program code of at least one other programming language embedded within the primary application program code. A selective testing framework can be designed that efficiently evaluates embedded program code separately from the host application program code. The selective testing framework records specified embedded program code detected during execution of the application. Recording the embedded program code while the application executes allows the selective testing framework to incrementally construct an independently testable program in accordance with execution of the application. The testing framework can then test the constructed program code as it would run within the application, but test it external to and independent of the application. Without the overhead of executing the primary program code (e.g., compiling and building an installer), embedded program code can be efficiently evaluated.