. Traditionally, integrity constraints in database systems are maintained either by rolling back any transaction that produces an inconsistent state or by disallowing or modifying operations that may produce an inconsistent state. An alternative approach is to provide automatic "repair " of inconsistent states using production rules. For each constraint, a production rule is used to detect constraint violation and to initiate database operations that restore consistency. We describe an SQL-based language for defining integrity constraints and a framework for translating these constraints into constraint-maintaining production rules. Some parts of the translation are automatic while other parts require user intervention. Based on the semantics of our set-oriented production rules language and under certain assumptions, we prove that at the end of each transaction the rules are guaranteed to produce a state satisfying all defined constraints. We apply our approach to a good-sized example...

. It is widely recognized that production rules in database systems can be used to automatically maintain derived data such as views. However, writing a correct set of rules for efficiently maintaining a given view can be a difficult and ad-hoc process. We provide a facility whereby a user defines a view as an SQL select expression, from which the system automatically derives set-oriented production rules that maintain a materialization of that view. The maintenance rules are triggered by operations on the view's base tables. Generally, the rules perform incremental maintenance: the materialized view is modified according to the sets of changes made to the base tables, which are accessible through logical tables provided by the rule language. However, for some operations substantial recomputation may be required. We give algorithms that, based on key information, perform syntactic analysis on a view definition to determine when efficient maintenance is possible. 1 Introduction In rel...

Query processing can be sped up by keeping frequently accessed users' views materialized. However, the need to access base relations in response to queries can be avoided only if the materialized view is adequately maintained. We propose a method in which all database updates to base relations are first filtered to remove from consideration those that cannot possibly affect the view. The conditions given for the detection of updates of this type, called irrelevant updates, are necessary and sufficient and are independent of the database state. For the remaining database updates, a differential algorithm can be applied to re-evaluate the view expression. The algorithm proposed exploits the knowledge provided by both the view definition expression and the database update operations. 1 Introduction In a relational database system, a database may be composed of both base and derived relations. A de- This work was supported in part by scholarship No. 35957 from Consejo Nacional de Cien...

Database updates are small and incremental compared to database contents. It is therefore desirable that recomputations of active relational expressions -- such as views, derived data, integrity constraints, active queries, and monitors -- can be performed incrementally as well. We present an efficient algorithm for the incremental recomputation of active relational expressions based on finite differencing techniques. Database updates are modeled as incremental changes to database relations, and the algorithm derives, by update propagation, the minimal incremental relational expressions that need recomputation. The algorithm has applications in the maintenance of materialized views and derived data, the checking of integrity constraints, and the evaluation of active queries and monitors. Keywords--- Active Queries, Derived Data, Finite Differencing, Incremental Recomputation, Integrity Constraints, Monitors, Updates, Views I. Introduction Database management systems need to perform ...

We present an exception handling facility suitable for languages used to implement database-intensive Information Systems. Such a mechanism facilitates the development and maintenance of more flexible software systems by supporting the abstraction of details concerning special or abnormal occurrences. We consider the type constraints imposed by the schema as well as various semantic integrity assertions to be normalcy conditions, and the key contribution of this work is to allow exceptions to these constraints to persist. To achieve this, we propose solutions to a range of problems, including sharing and computing with exceptional information, exception handling by users, the logic of constraints with exceptions, and implementation issues. We also illustrate the use of exception handling in dealing with null values, estimates, and measurements. Keywords and phrases: semantic integrity, violations of type constraints, exception handling, accommodating exceptions, conceptual models CR ...

We present a basis for efficiently evaluating the situation (event and condition) portion of situation/action rules. either in an active database or in a standalone situation monitor. A common framework handles situations involving both database changes and nondatabase situations. We introduce ARelations to represent net changes to a stored or derived relation. We define an operator that computes ARelations for derived relations. Evaluation of expressions involving changes is optimized by defining incremental forms of relational operators and by providing a chain rule that extends incremental computation to data derived by arbitrary expressions. 1.

This paper presents a difference calculus for determining changes to rule conditions in an active DBMS. The calculus has been used for implementing an algorithm to efficiently monitor rules with complex conditions. The calculus is based on partial differencing of queries derived from rule conditions. For each rule condition several partially differentiated queries are generated that each considers changes to a single base relation or view that the condition depends on. The calculus considers both insertions and deletions. The algorithm is optimized for deferred rule condition monitoring in transactions with few updates. The calculus allows us to optimize both space and time. Space optimization is achieved since the calculus and the algorithm does not presuppose materialization of monitored conditions to find its previous state. This is achieved by using a breadth-first, bottom-up propagation algorithm and by calculating previous states by doing a logical rollback. Time optimization is ...

Database programming requires knowledge of database semantics both to maintain database integrity and to explore more optimization opportunities. Automated programming of database transactions is desirable and feasible. In general, transactions use simple constructs and algorithms; specifications of database semantics are available; and transactions perform small incremental updates to database contents. Automated programming in such a restricted but well-understood and important domain is promising. We approach the synthesis of database transactions that preserve the validity of integrity constraints using deductive techniques. A transaction logic for a fairly expressive class of transactions is developed as the formalism within which the synthesis is conducted. Transactions are generated as the by-product of proving specifications in the logic. The Manna-Waldinger deductive-tableau system is extended with inference rules for the extraction of transactions from proofs, which require t...

We present an approach for integrating inter-object constraint maintenance seamlessly into an object-oriented database system. We develop a constraint compilation scheme that accepts declarative global specification of constraints, including relational integrity, referential integrity, and uniqueness requirements, and generates an efficient representation that permits localized processing. We demonstrate the feasibility of our approach by designing a constraint pre-processor for O*, the programming language interface to the Ode object-oriented database. 1.

This paper briefly surveys what transformational programming is about, and how to make progress in the field. A program transformation is a meaning-preserving mapping defined on a programming language. Transformational programming is a program development methodology in which an implementation I is obtained from a specification S by applying a sequence T k :::T 1 of transformations to S. If S and each transformation T i applied to successive implementations T i\Gamma1 :::T 1 S of S are proved correct for