Ernest Teniente

A Survey of Current Methods for Integrity Constraint Maintenance and View Updating

During the process of updating a database, two interrelated problems could arise. On one hand, when an update is applied to the database, integrity constraints could become violated, thus falsifying database consistency. In this case, the integrity constraint maintenance approach tries to obtain additional updates to be applied to re-establish database consistency. On the other hand, when an update request consist on updating some derived predicate, a view updating mechanism must be applied to translate the update request into correct updates on the underlying base facts. In this paper, we propose a general framework to compare and classify current methods in the field of view updating and integrity constraint maintenance. In this sense, we classify them considering how they tackle with both problems and, we also state the main drawbacks these methods have.

OCL-Lite: Finite reasoning on UML/OCL conceptual schemas

To ensure the quality of an information system we must guarantee the correctness of the conceptual schema that represents the knowledge about its domain. The high expressivity of UML schemas annotated with textual OCL constraints enforces the need for automated reasoning techniques. These techniques should be both terminating and complete to be effectively used in practice. In this paper we identify an expressive fragment of the OCL language that ensures these properties. In this way, we overcome the limitations of current techniques when reasoning on such a fragment. As a consequence, we also have that Description Logics can be appropriately used to reason on UML conceptual schemas with arbitrary OCL constraints. We also show how current tools based on different approaches can be used to reason on conceptual schemas enriched with (a decidable fragment of) OCL constraints.

Updating knowledge bases while maintaining their consistency

When updating a knowledge base, several problems may arise. One of the most important problems is that of integrity constraints satisfaction. The classic approach to this problem has been to develop methods forchecking whether a given update violates an integrity constraint. An alternative approach consists of trying to repair integrity constraints violations by performing additional updates thatmaintain knowledge base consistency. Another major problem in knowledge base updating is that ofview updating, which determines how an update request should be translated into an update of the underlying base facts. We propose a new method for updating knowledge bases while maintaining their consistency. Our method can be used for both integrity constraints maintenance and view updating. It can also be combined with any integrity checking method for view updating and integrity checking. The kind of updates handled by our method are: updates of base facts, view updates, updates of deductive rules, and updates of integrity constraints. Our method is based on events and transition rules, which explicity define the insertions and deletions induced by a knowledge base update. Using these rules, an extension of the SLDNF procedure allows us to obtain all possible minimal ways of updating a knowledge base without violating any integrity constraint.

Incremental integrity checking of UML/OCL conceptual schemas

Integrity constraints play a key role in the specification and development of software systems since they state conditions that must always be satisfied by the system at runtime. Therefore, software systems must include some kind of integrity checking component that ensures that all constraints still hold after the execution of any operation that modifies the system state. Integrity checking must be as efficient as possible not to seriously slow down the system performance at runtime. In this sense, this paper proposes a set of techniques to facilitate the efficient integrity checking of UML-based software specifications, usually complemented with a set of integrity constraints defined in Object Constraint Language (OCL) to express all rules that cannot be graphically defined. In particular, our techniques are able to determine, at design-time, when and how each constraint must be checked at runtime to avoid irrelevant verifications. We refer to these techniques as incremental because they minimize the subset of the system state that needs to be checked after each change by assuming that the system was initially in a consistent state and just reevaluating the elements that may have been affected by that change. We also show how the techniques can be integrated in a model-driven development framework to automatically generate a final implementation that automatically checks all constraints in an incremental way.

Verification and Validation of UML Conceptual Schemas with OCL Constraints

To ensure the quality of an information system, it is essential that the conceptual schema that represents the knowledge about its domain is semantically correct. The semantic correctness of a conceptual schema can be seen from two different perspectives. On the one hand, from the point of view of its definition, a conceptual schema must be right. This is ensured by means of verification techniques that check whether the schema satisfies several correctness properties. On the other hand, from the point of view of the requirements that the information system should satisfy, a schema must also be the right one. This is ensured by means of validation techniques, which help the designer understand the exact meaning of a schema and to see whether it corresponds to the requirements. In this article we propose an approach to verify and validate UML conceptual schemas, with arbitrary constraints formalized in OCL. We have also implemented our approach to show its feasibility.

Reasoning on UML class diagrams with OCL constraints

We propose a new approach to check whether a given UML class diagram with its OCL integrity constraints satisfies a set of desirable properties such as schema satisfiability, class liveliness, redundancy of integrity constraints or reachability of partially specified states. Our approach is based on translating both the class diagram and the OCL constraints into a logic representation. Then, we use the CQC Method to verify whether these properties hold for the given diagram and constraints.

Transformation techniques for OCL constraints

Constraints play a key role in the definition of conceptual schemas. In the UML, constraints are usually specified by means of invariants written in the OCL. However, due to the high expressiveness of the OCL, the designer has different syntactic alternatives to express each constraint. The techniques presented in this paper assist the designer during the definition of the constraints by means of generating equivalent alternatives for the initially defined ones. Moreover, in the context of the MDA, transformations between these different alternatives are required as part of the PIM-to-PIM, PIM-to-PSM or PIM-to-code transformations of the original conceptual schema.

Constraint support in MDA tools: a survey

The growing interest in the MDA (Model-Driven Architecture) and MDD (Model-Driven Development) approaches has largely increased the number of tools and methods including code-generation capabilities. Given a platform-independent model (PIM) of an application, these tools generate (part of) the application code either by defining first a platform-specific model or by executing a direct PIM to code transformation. However, current tools present several limitations regarding code generation of the integrity constraints defined in the PIMs. This paper compares these tools and shows that they lack expressiveness in the kind of constraints they can handle or efficiency in the code generated to verify them. Based on this evaluation, the features of an ideal code-generation method for integrity constraints are established. We believe such a method is required to extend MDA adoption in the development of industrial projects, where constraints play a key role.

Decidable Reasoning in UML Schemas with Constraints

In this paper we propose an approach to reason on UML schemas with OCL constraints. We provide a set of theorems to determine that a schema does not have any infinite model and then provide a decidable method that, given a schema of this kind, efficiently checks whether it satisfies a set of desirable properties such as schema satisfiability and class or association liveliness.

The Events Method for View Updating in Deductive Databases

We propose a new method for view updating in deductive databases. The method is based on events and transition rules, which explicitly define the insertions and deletions induced by a database update. Using these rules, an extension of the SLDNF procedure allows us to obtain all valid translations of view update requests. The main advantages of the method are its simplicity, the uniform treatment of insert and delete requests and the integration of integrity checking during the derivation process. The method has the full power of the methods developed so far, without some of their limitations.