Incremental integrity checking in UML/OCL Conceptual Schemas

Tweet about this on TwitterShare on FacebookBuffer this pageShare on RedditShare on LinkedInShare on Google+Email this to someone

This is a “going down the memory lane” kind of post but while working in my member page on our team website I realized that my Phd Thesis had never been featured in this blog. It makes sense since the thesis was finished three years before the blog started but I still think it’s of justice to add it even if we are almost 10 years late.

Obviously, the field of incremental evaluation of OCL constraints has advanced since I finished my thesis (though not so much as you may think) but I do believe it’s still worth checking out (for those just wanting to take a quick look at the main ideas behind the work, this article could be a better option).

The shortest possible summary would be that instead of evaluating all constraints on the whole data after every change (to make sure the data is still consistent with the constraints after an insert/update/delete event) our method would:

  1. Identify what constraints really need to be reevaluated (e.g. a change in the name of a department won’t violate a constraint regarding the minimum salary of employees in the company and therefore we don’t need to reevalaute that constraint when updating it).
  2. Detecting what specific instances may become inconsistent after a change (e.g. changing the salary of an employee e may make e inconsistent with the previous salary constraint but not the rest, which can be safely discarded during the reevaluation).
  3. Optimize the constraint expression depending on the potential violating event. Once we know what constraints may have been violated by a modification on the data and know what concrete instances need to be checked, we would create a specific version of the constraint to speed up the evaluation process on that specific context

Below the “official” abstracts (reads a little “old fashioned” specially regarding the terminology used at the time 🙂 ) and the full pdf.

Abstract:

Integrity constraints play a fundamental role in the definition of conceptual schemas (CSs) of information systems. An integrity constraint defines a condition that must be satisfied in each state of the information base (IB). Hence, the information system must guarantee that the state of the IB is always consistent with respect to the integrity constraints of the CS. This process is known as integrity checking. Unfortunately, current methods and tools do not provide adequate integrity checking mechanisms since most of them only admit some predefined types of constraints. Moreover, the few ones supporting a full expressivity in the constraint definition language present a lack of efficiency regarding the verification of the IB.

In this thesis, we propose a new method to deal with the incremental evaluation of the integrity constraints defined in a CS. We consider CSs specified in the UML with constraints defined as OCL invariants. We say that our method is incremental since it adapts some of the ideas of the well-known methods developed for incremental integrity checking in deductive and relational databases. The main goal of these incremental methods is to consider as few entities of the IB as possible during the evaluation of an integrity constraint. This is achieved in general by reasoning from the structural events that modify the contents of the IB. Our method is fully automatic and ensures an incremental evaluation of the integrity constraints regardless their concrete syntactic definition.

The main feature of our method is that it works at the conceptual level. That is, the result of our method is a standard CS. Thus, the method is not technology-dependent and, in contrast with previous approaches, our results can be used regardless the final technology platform selected to implement the CS. In fact, any code-generation method or tool able to generate code from a CS could be enhanced with our method to automatically generate incremental constraints, with only minor adaptations. Moreover, the efficiency of the generated constraints is comparable to the efficiency obtained by existing methods for relational and deductive databases.

Full document: Download it here

Ah, if you’d like to take a look at my “second thesis”, i.e. my habilitation thesis, check it out here

Tweet about this on TwitterShare on FacebookBuffer this pageShare on RedditShare on LinkedInShare on Google+Email this to someone
Comments
  1. Antonio Carrasco Valero

Reply

Your email address will not be published. Required fields are marked *