. 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...

The purpose of this paper is to show that logic provides a convenient formalism for studying classical database problems. There are two main parts to the paper, devoted respectively to conventional databases and deductive databases. In the first part, we focus on query languages, integrity modeling and maintenance, query optimization, and data

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 ...

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...

ing with credit is permitted. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from Publications Dept, ACM Inc., fax +1 (212) 869-0481, or permissions@acm.org. Verifiable Properties of Database Transactions Michael Benedikt Timothy Griffin Leonid Libkin Bell Laboratories 600 Mountain Avenue, Murray Hill NJ 07974, USA e-mail: fbenedikt, griffin, libking@research.att.com Abstract It is often necessary to ensure that database transactions preserve integrity constraints that specify valid database states. While it is possible to monitor for violations of constraints at run-time, rolling back transactions when violations are detected, it is preferable to verify correctness statically, before transactions are executed. This can be accomplished if we can verify transaction safety with respect to a set of constraints by means of calculating weakest preconditions. We study properties o...

Abstract. Complete checks of database integrity constraints may be prohibitively time consuming, and several methods have been suggested for producing simplified checks for each update. The present approach introduces a set of transformation operators that apply to database integrity constraints with each operator representing a concise, semanticspreserving operation. These operators are applied in a procedure producing simplified constraints for parametric transaction patterns, which then can be instantiated and checked for consistency at run-time but before any transaction is executed. The operators provide a flexibility for other database enhancements and the work may also be seen as more systematic and general when compared with other approaches. The framework is formulated with first-order clause logic but with the perspective of being applied with present-day database technology. 1

Integrity constraint checking for stratifiable deductive databases has been studied by many authors. However, most of these methods may perform unnecessary checking if the update is irrelevant to the constraints. [Lee94] proposed a set called relevant set which can be incorporated in these works to reduce unnecessary checking. [Lee94] adopts a top-down approach and makes use of constants and evaluable functions in the constraints and deductive rules to reduce the search space. In this paper, we further extend this idea to make use of relational predicates, instead of only constants and evaluable functions in [Lee94]. We first show that this extension is not a trivial one as extra database retrieval cost is incurred. We then present a new method to construct a pre-test which can be incorporated in most existing methods to reduce the average checking costs in terms of database accesses by a significant factor. Our method also differs from other partial checking methods as we can handle m...

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.

The general architecture of a monitor that enforces inclusion dependencies and referential integrity is described. The monitor traces the operations a user submits in a session and can either modify an operation or propagate it, depending on additional information the database designer provided at design time. Propagation is implemented by executing new operations when the session terminates, using summary data collected during normal processing. 1.

In this paper, we propose an efficient and reliable method to deal with integrity constraints in a persistent object system. First we provide the application programmer with the ability to express integrity constraints but we also give him the possibility to use high level language constructs to help him in writing safe transactions. The goal of our approach is to avoid the (run time) checking of constraints by proving formally that transactions preserve integrity constraints. We mainly use two abstract interpretation techniques to do that. Abstract interpretation is a semantics-based tool that yields some reliable information about the possible run-time behaviour of programs, with fully automatic algorithms. We present informally the methods that we use: a simple method, based on path reachability, and a more powerful and complex method that uses a predicate transformer. A predicate transformer is a function that, given a transaction and a formula describing its input data, yields a f...