Loose Triggers for Deferred Entity Coupling
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional database triggers, known as 'tight triggers,' are inefficient because they require specific entities to be defined and applied at the time of database creation and compilation, limiting flexibility and usability when the entity is not defined at that time.
Innovation Solution
The introduction of 'loose triggers' that can be coupled to one or more entities selected by a user after the trigger code has been compiled, allowing for deferred definition of trigger entities and optional coupling to a predetermined set of entities, with validation processes to ensure validity and error handling.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If tight triggers are used with specific entities defined at compilation time, then the trigger code can be optimized and compiled efficiently, but the system loses flexibility and cannot adapt to entities defined later
Solution Approach 1:
The patent segments the trigger system into two independent parts: the trigger code (procedural logic) and the entity coupling (association relationship). This allows the trigger code to be compiled independently without requiring specific entity definitions, while entity coupling is established separately at runtime through metadata, resolving the contradiction between compilation efficiency and adaptability.
Solution Approach 2:
The patent introduces dynamic entity coupling where triggers can be associated with entities after compilation through runtime metadata. The system dynamically determines which entities are coupled to which triggers during execution, allowing the trigger system to adapt to different entities without recompilation, thus achieving both efficiency and flexibility.
2Device complexity
If triggers are coupled to specific entities at database creation time, then the system structure is simple and straightforward, but it requires recompilation when entities are added or modified later
Solution Approach 1:
The patent performs preliminary compilation of trigger code without entity-specific bindings. The trigger procedural logic is compiled in advance as a standalone component, and entity couplings are established later through metadata registration. This preliminary action separates compilation from entity association, simplifying the overall system structure while easing deployment.
Solution Approach 2:
The patent introduces metadata as an intermediary layer between trigger code and entities. Instead of direct coupling, metadata serves as a mediator that associates triggers with entities at runtime. This intermediary structure maintains simplicity while enabling easy deployment and modification without recompilation.
3Adaptability or versatility
If loose triggers are implemented with deferred entity coupling, then flexibility and adaptability improve, but validation complexity and error handling requirements increase
Solution Approach 1:
The patent implements self-service validation where the system automatically validates entity-trigger couplings through metadata registration processes. The validation logic is embedded in the coupling mechanism itself, automatically checking compatibility without requiring complex external validation procedures, thus managing complexity while maintaining flexibility.
Solution Approach 2:
The patent incorporates feedback mechanisms in the form of validation results and error messages that guide the coupling process. When entities are coupled to triggers through metadata, the system provides immediate feedback on validity, allowing for automatic correction or user guidance, which manages complexity through structured feedback rather than complex preventive validation.
Data Source
AI summary
A database program includes loose triggers that are not coupled to specific entities at the time the database program is compiled. The database program provides a user interface that allows a user to couple selected entities to the loose triggers or decouple selected entities from loose triggers. The database program validates the entities that are selected by the user for coupling or decoupling and stores the coupled entities as part of the loose trigger definitions in a loose trigger metadata database.