# Simplified Integrity Checking for an Expressive Class of Denial Constraints
## 6 Conclusions  
We applied program transformation operators to the generation of simplified integrity constraints, targeting an expressive class termed extended denials, which includes negated existential quantifiers. We believe that this is an important class, as it encompasses very common dependencies such as tuple-generating dependencies and equality-generating dependencies.  
An immediate application of our operators is an automated process that, upon requests from an application, communicates with the database and transparently carries out the required simplified integrity checking operations. The would imply benefits in terms of efficiency and could leverage a compiled approach, since simplifications can be generated at design time for the most common update patterns.  
Although we used a logical notation, standard ways of translating integrity constraints into SQL exist. Further investigation is needed in order to handle additional language concepts of SQL like null values. In [13], [PERSON] showed how to implement integrity constraint checking by translating first-order logic specifications into SQL triggers. The result of our transformations can be combined with similar translation techniques and thus integrated in an active database system, according to the idea of embedding integrity control in triggers. In this way, the advantages of declarativity are combined with the efficiency of execution.  
Other possible enhancements of the proposed framework may be developed using statistical measures on the data, such as estimated relation sizes and cost measurements for performing join and union operations. Work in this area is closely related to methods for dynamic query processing, e.g., [96; 97].  
The proposed procedure is guaranteed to terminate, as we approximated entailment with rewrite rules based on resolution, subsumption, and replacement of specific patterns. While [15] discusses a few cases in which, besides termination, the procedure guarantees also completeness, it would be interesting to pinpoint more specifically what is left out in more expressive cases. A careful evaluation of the effectiveness of a simplification procedure for integrity checking is still an open problem: besides the lack, even in theory, of a univocal definition of \"perfect\" simplification, there is no benchmark specifically designed for this task and, even though some attempts exist at synthetically generating complex database schemata (as in [95]), these are not matched with update patterns and integrity constraints and, therefore, do not offer any ground truth to compare with. Additionally, the very interest and practical relevance of a synthetic schema generation, which is the typical result of a careful design by database experts, would be debatable at the very least.  
Another line of research regards the combination of extended denials with other expressive scenarios, also individually described in [15], such as the addition of aggregates and arithmetic built-ins. While all these extensions could be trivially handled by a rule set comprising all rewrite rules defined for each specific scenario (such rules are mutually exclusive), it should be interesting to study whether further improvements can be obtained by exploiting the interaction between these rules. This is a limitation of our study which could be addressed by future work.  
This research received no external funding.  
No datasets were used for the purposes of this theoretical paper.