A transaction repair system detects erroneous transactions as they update the database, and for each erroneous transaction, it finds the necessary and sufficient changes to the transaction that would repair it. Detection and repair are the two essential components of semantic integrity maintenance since detection alone would leave the user with the difficult responsibility of manually correcting and reentering an erroneous transaction. Both detection and repair rely on incremental integrity maintenance techniques. The detection process takes advantage of the integrity of the database before the transaction, and detects only the new errors introduced by the transaction. The repair process takes advantage of the integrity before the transaction and integrity violation after the transaction but before the repair. Such a two-step incremental analysis produces the minimal repair necessary and sufficient to correct the transaction. All necessary and sufficient repairs are generated, for all first order constraints, and by using only substitution with no resolution search. Multiple constraints are repaired in parallel, with no sequencing of constraints, and no possibility of cycles. Extensions to recursive constraints and nondeterministic transactions are provided.

First order static database constraints are expressed in terms of updates that may violate them, and the updates that will block those violations. Such simple necessary conditions for violations, and sufficient conditions for validations are useful in storing database constraints on secondary storage devices, maintaining them using relational database management systems, and retrieving them using database query languages. Considerable efficiency in constraint management is achieved by retrieving only the relevant constraints for each database stransaction. A large proportion of constraints are eliminated from consideration without retrieval from the storage device, and without any significant processing. Storage structure provides indexing with respect to relations, constants, quantifiers, and arbitrary join conditions.

A differential calculus for first-order logic is developed to enforce database integrity. Formal differentiation of first-order sentences is useful in maintaining database integrity, since once a database constraint is expressed as a first-order sentence, its derivative with respect to a transaction provides the necessary and sufficient condition for maintaining integrity. The derivative is often much simpler to test than the original constraint since it maintains integrity differentially by assuming Integrity before the transaction, and testing only for new violations. The formal differentiation requires no resolution search, only substitution. It is more efficient than resolution-based approaches; and it provides a considerably more general solution than previous substitution-based methods since it is valid for all first-order sentences and with all transactions involving arbitrary collections of atomic changes to the database. It also produces a large number of sufficient conditions that are often less strict than those of the previous approaches; and it can be extended to accommodate many dynamic constraints.

First order static database constraints are expressed as counterexamples, i.e., examples that violate the integrity of the database. Examples are data and as such they can be specified and stored as data, structured into database files for efficient search and retrieval, and enforced efficiently since enforcement reduces to data comparison between the constraints as example data and the database. To express all first order constraints as counterexamples, a new normal form for first order logic is created which, after some syntactic transformation, is amenable to storage in flat files, efficient search and retrieval, and efficient testing of models for validity. Such efficient management of constraints is likely to lead to the development of large constraint bases since constraints are useful in a variety of contexts such as: 1. Maintaining data quality by catching in real time and eliminating a wide variety of errors ranging from typing mistakes to complex semantic violations, 2. Enforcing data security by monitoring and authorizing access and modification to protected data, 3. Implementing semantic data models within the simpler and better understood environment of relational model, 4. Building model libraries where complex decision models can be described, stored, retrieved, and manipulated by using constraints that establish the logical relationships between their inputs and outputs.

Database queries can be expressed as unordered collections of examples and counterexamples. The resulting languages are intuitive, first order complete, and applicable to a variety of data models including relational, object oriented, and visual models. This class of languages based on examples and counterexamples employ a minimal number of constructs with no sequencing or nesting of the constructs implied, allowing a simple and uniform theoretical analysis of their syntax, semantics, and completeness.

The maintenance cost of database constraints is proposed as a data model design criterion. All previous design criteria are shown to be special cases of constraint maintenance. A human oriented design procedure based on this criterion is developed and shown to be applicable to a variety of data models including relational and functional. Human orientation is achieved by using natural deduction instead of resolution, simple heuristics instead of global optimisation, and a functional notation.

An exclusively visual approach to the development of database applications is introduced. Graphical tools and techniques are designed to represent all components of an application system, and all phases of the development process. Data, constraints, queries, transactions and programs are all expressed graphically. Analysis, design, maintenance, and even inference are carried out using graphical techniques. The visual approach is expected to be most appropriate for end users, and it is likely to encourage end-user participation in application development.

A general notation is developed based on functional languages and Horn clauses to express database constraints. A general notation not only provides a medium for a comprehensive study of all database constraints, as opposed to individual types of constraints, but it also reveals that constraints constitute a major building block of many other database components. In that respect, they are likely to aid in the study of all of those components ranging from queries and transactions to derivations and design algorithms. A universal building block is also likely to be the first step in the development of a unifying theory.

A highly modular and uniformly functional development methodology for database applications is introduced. An event-oriented view of the database is adopted recording the observed events directly and treating the state of the environment as derived data. The relationship between the observed events and the derived state of the system is expressed using a purely functional language. The application systems in this environment are divided into their smallest possible components consisting of only functions and simple functional expressions. The multimode of small but highly independent components generated in this fashion are placed in the database along with the data, to utilize the database management system in maintaining the application system. The semantics of individual applications is captured within the data model serving those applications.>