The Experts below are selected from a list of 279 Experts worldwide ranked by ideXlab platform

Ernest Teniente - One of the best experts on this subject based on the ideXlab platform.

  • embedding reactive behavior into artifact centric business process models
    Future Generation Computer Systems, 2021
    Co-Authors: Xavier Oriol, Giuseppe De Giacomo, Montserrat Estanol, Ernest Teniente
    Abstract:

    Abstract In artifact-centric business process models it is usually assumed that the specification of the activities requires stating all the effects of the activity execution over the information base (i.e. over the artifacts it handles). In particular, these effects have to deal with Integrity Constraint enforcement to ensure a proper treatment of Integrity Constraints during activity execution. Manually specifying this treatment is a difficult, expensive and error-prone task, because of the inherent difficulty of getting rid of all the implication entailed by the Constraints and also of the way to properly handle it. In this paper, we advocate for separating Constraint handling from the specification of activities in such a way that only the effects of the activity over the artifacts have to be defined (without needing to care about the Constraints). Then, we propose an approach to automatically generate an extension to the original business process model that allows identifying at run-time the additional updates that have to be applied to the information base to repair all Constraint violations caused by the activity execution.

  • determining the structural events that may violate an Integrity Constraint
    Lecture Notes in Computer Science, 2004
    Co-Authors: Jordi Cabot, Ernest Teniente
    Abstract:

    Any implementation of an information system must ensure that an operation is only applied if its execution does not lead to a violation of any of the Integrity Constraints defined in its conceptual schema. In this paper we propose a method to automatically determine the operations that may potentially violate an OCL Integrity Constraint in conceptual schemas defined in the UML. This is done by determining the structural events that may violate the Constraint and checking whether those events appear in the operation specification. In this way, our method helps to improve efficiency of Integrity checking since its results can be used to discard many irrelevant tests.

  • on the abductive or deductive nature of database schema validation and update processing problems
    arXiv: Databases, 2003
    Co-Authors: Ernest Teniente, Toni Urpi
    Abstract:

    We show that database schema validation and update processing problems such as view updating, materialized view maintenance, Integrity Constraint checking, Integrity Constraint maintenance or condition monitoring can be classified as problems of either abductive or deductive nature, according to the reasoning paradigm that inherently suites them. This is done by performing abductive and deductive reasoning on the event rules [Oli91], a set of rules that define the difference between consecutive database states In this way, we show that it is possible to provide methods able to deal with all these problems as a whole. We also show how some existing general deductive and abductive procedures may be used to reason on the event rules. In this way, we show that these procedures can deal with all database schema validation and update processing problems considered in this paper.

  • on the abductive or deductive nature of database schema validation and update processing problems
    Theory and Practice of Logic Programming, 2003
    Co-Authors: Ernest Teniente, Toni Urpi
    Abstract:

    We show that database schema validation and update processing problems such as view updating, materialized view maintenance, Integrity Constraint checking, Integrity Constraint maintenance or condition monitoring can be classified as problems of either abductive or deductive nature, according to the reasoning paradigm that inherently suites them. This is done by performing abductive and deductive reasoning on the event rules (Olive 1991), a set of rules that define the difference between consecutive database states. In this way, we show that it is possible to provide methods able to deal with all these problems as a whole. We also show how some existing general deductive and abductive procedures may be used to reason on the event rules. In this way, we show that these procedures can deal with all database schema validation and update processing problems considered in this paper.

  • dealing with modification requests during view updating and Integrity Constraint maintenance
    Foundations of Information and Knowledge Systems, 2000
    Co-Authors: Enric Mayol, Ernest Teniente
    Abstract:

    An important problem that arises when updating a deductive database is that of Integrity Constraint maintenance. That is, given a consistent database and an update request, to obtain all possible updates of base facts such that the request is satisfied and no Integrity Constraint is violated. This problem becomes more complex when view updates are also taken into account. In this paper we define a method for view updating and Integrity Constraint maintenance in deductive databases. We propose a new method that is sound and that improves current methods by dealing with three kinds of updates: insertion, deletion and modification updates on base and derived predicates. Moreover, due to the inclusion of an specific modification operator, the own definition of the method deals with key information of base and derived predicates.

J Sistac - One of the best experts on this subject based on the ideXlab platform.

  • applying transition rules to bitemporal deductive databases for Integrity Constraint checking
    Logic in Databases, 1996
    Co-Authors: C Martin, J Sistac
    Abstract:

    A bitemporal deductive database is a deductive database that supports valid and transaction time. A set of facts to be inserted and/or deleted in a bitemporal deductive database can be done in a past, present or future valid time. This circumstance causes that the maintenance of database consistency becomes more hard. In this paper, we present a new approach to reduce the difficulty of this problem, based on applying transition and event rules, which explicitly define the insertions and deletions given by a database update. Transition rules range over all the possible cases in which an update could violate some Integrity contraint. Although, we have a large amount of transition rules, for each one we argue its utility or we eliminate it. We augment a database with this set of transition and event rules and then standard SLDNF resolution can be used to check satisfaction of Integrity Constraints.

  • an Integrity Constraint checking method for temporal deductive databases
    International Symposium on Temporal Representation and Reasoning, 1996
    Co-Authors: C Martin, J Sistac
    Abstract:

    The authors propose a method for Integrity checking in the context of temporal deductive databases. A temporal deductive database is a deductive database that supports some aspect of time, in our case valid time, in which valid time is the time when the fact is true in the modelled reality. Their method augments a database with a set of transition and event rules, which explicitly define the insertions and deletions by database update. Standard SLDNF resolution can then be used to check satisfaction of Integrity Constraints. A temporal deductive database has to be consistent, that is, after performing an update the database must satisfy its set of Integrity Constraints. Using their method the temporal deductive database is always consistent because if a retroactive or proactive update violated some Integrity Constraint the update would be rejected.

B. Eaglestone - One of the best experts on this subject based on the ideXlab platform.

  • an Integrity Constraint for database systems containing embedded static neural networks
    International Journal of Intelligent Systems, 2001
    Co-Authors: I. Millns, B. Eaglestone
    Abstract:

    Static neural networks are used in some database systems to classify objects, but like traditional statistical classifiers they often misclassify. For some applications, it is necessary to bound the proportion of misclassified objects. This is clearly an Integrity problem. We describe a new Integrity Constraint for database systems with embedded static neural networks, with which a database administrator can enforce a bound on the proportion of misclassifications in a class. The approach is based upon mapping probabilities generated by a probabilistic neural network to the likely percentage of misclassifications.

  • An Integrity Constraint for database systems containing embedded neural networks
    Proceedings Ninth International Workshop on Database and Expert Systems Applications (Cat. No.98EX130), 1998
    Co-Authors: I. Millns, B. Eaglestone
    Abstract:

    Neural networks are used in some database systems to classify objects, but like traditional statistical classifiers they often misclassify. For some applications, it is necessary to bound the proportion of misclassified objects. This is clearly an Integrity problem. We describe a new Integrity Constraint for database systems with embedded neural networks, with which Database Administrator can enforce a bound on the proportion of misclassifications in a class. The approach is based upon mapping probabilities generated by a probablistic neural network to the likely percentage of misclassifications

W A Gray - One of the best experts on this subject based on the ideXlab platform.

  • an Integrity Constraint management framework in engineering design
    Computers in Industry, 2002
    Co-Authors: Jeevani S Goonetillake, T W Carnduff, W A Gray
    Abstract:

    Due to the evolutionary nature of the engineering design process it is necessary to provide support for version management. The version model should be provided with an Integrity checking mechanism to assure the consistency of object versions with the design Constraints. Managing Integrity Constraints is complex due to their evolving nature and raises number of issues that need to be dealt with. In this paper we present a conceptual framework for providing an Integrity mechanism for object versions and show how it operates in a co-operative and distributed design environment. The framework is based on the concept of the Constraint version object (CVO).

  • Integrity Constraint management for design object versions in a concurrent engineering design environment
    International Database Engineering and Applications Symposium, 2001
    Co-Authors: Jeevani S Goonetillake, T W Carnduff, W A Gray
    Abstract:

    Concurrent engineering (CE) is a product development approach which requires a collaborative multidisciplinary team environment with effective communication. Due to the evolutionary nature of the engineering design process, it is necessary to provide support for version management. The version model should be provided with an Integrity checking mechanism to assure the consistency of object versions with the design Constraints. Managing Integrity Constraints is complex due to their evolving nature and raises a number of issues that need to be dealt with. The authors present a conceptual framework for providing an Integrity mechanism for object versions. The framework is based on the concept of the Constraint Version Object (CVO).

  • the development of a semantic Integrity Constraint subsystem for a distributed database
    British National Conference on Databases, 1996
    Co-Authors: H Ibrahim, W A Gray, N J Fiddian
    Abstract:

    This paper presents a strategy for validating the semantic Integrity Constraints of a distributed database. The general method detects inconsistency by performing Integrity tests against the database whenever an update occurs. The Integrity test is much cheaper and easier to validate than the initial Constraint. We use a two level approach where Constraint validation can be performed before or after an update is made. We adopt the algorithm proposed by [NIC82] to generate post-tests and modify it to generate pre-tests which allow the initial Constraints to be checked locally. This strategy has been implemented in a prototype system called SICSDD.

Xavier Schaefer - One of the best experts on this subject based on the ideXlab platform.

  • static Integrity Constraint management in object oriented database programming languages via predicate transformers
    European Conference on Object-Oriented Programming, 1997
    Co-Authors: Veronique Benzaken, Xavier Schaefer
    Abstract:

    In this paper, we propose an efficient technique to statically manage Integrity Constraints in object-oriented database programming languages. We place ourselves in the context of an extended version of the O2 database programming language, and we assume that updates are undertaken by means of methods. An important issue when dealing with Constraints is that of efficiency. A naive management of such Constraints can cause a severe floundering of the overall system. Our basic assumption is that the run-time checking of Constraints is too costly to be undertaken systematically. Therefore, methods that are always safe with respect to Integrity Constraints should be proven so at compile time. The run-time checks should only concern the remaining methods. To that purpose, we propose a new approach, based on abstract interpretation, to prove the invariance of Integrity Constraints under complex methods. We then describe the current implementation of our prototype, reporting many experiments that have been performed with it on non trivial examples.

  • static Integrity Constraint management in object oriented database programming languages via predicate transformers
    Lecture Notes in Computer Science, 1997
    Co-Authors: Veronique Benzaken, Xavier Schaefer
    Abstract:

    In this paper, we propose an efficient technique to statically manage Integrity Constraints in object-oriented database programming languages. We place ourselves in the context of an extended version of the O 2 database programming language, and we assume that updates are undertaken by means of methods. An important issue when dealing with Constraints is that of efficiency. A naive management of such Constraints can cause a severe floundering of the overall system. Our basic assumption is that the run-time checking of Constraints is too costly to be undertaken systematically. Therefore, methods that are always safe with respect to Integrity Constraints should be proven so at compile time. The run-time checks should only concern the remaining methods. To that purpose, we propose a new approach, based on abstract interpretation, to prove the invariance of Integrity Constraints under complex methods. We then describe the current implementation of our prototype, reporting many experiments that have been performed with it on non trivial examples. Though our method is developed in the context of object-oriented database programming languages, it can easily be applied to the problem of static verification of object-oriented languages providing pre and postconditions such as Eiffel.