Patterns of self-stabilization in database consistency maintenance

A substantial portion of the database programming efforts are invested in integrity constraints enforcement. Traditionally, both the constraint semantics and their enforcement were embedded inside application programs. In recent years several studies have dealt with specifying integrity constraints as separate entities (e.g. rules), and relating the database consistency requirements to these rules. In this paper we deal with the complementary issue of stabilizing the database when update exceptions occur. While a simplistic approach is to abort any transaction that inflicts consistency violations, this is not always the desired action. We take advantage of the empirical observation that most of the exception-handling policies follow a small number of behavior patterns. Unlike some previous approaches that base their repair solution on syntactic analysis of the constraints and performance issues, we base our approach on the application semantics as reflected in these behavioral patterns. We describe a model that uses high-level abstractions called stabilizer types denoting these behavior patterns for consistency restorations, whose exact semantics is case dependent. It follows the fault tolerance's self-stabilization approach. An inference mechanism translates these abstractions into executable active rules. This approach provides high-level language to the exception handling portion of the application and substantially reduces the required programming.     

A logical framework for querying and repairing inconsistent databases

In this paper, we address the problem of managing inconsistent databases, i.e., databases violating integrity constraints. We propose a general logic framework for computing repairs and consistent answers over inconsistent databases. A repair for a possibly inconsistent database is a minimal set of insert and delete operations which makes the database consistent, whereas a consistent answer is a set of tuples derived from the database, satisfying all integrity constraints. In our framework, different types of rules defining general integrity constraints, repair constraints (i.e., rules defining conditions on the insertion or deletion of atoms), and prioritized constraints (i.e., rules defining priorities among updates and repairs) are considered. We propose a technique based on the rewriting of constraints into (prioritized) extended disjunctive rules with two different forms of negation (negation as failure and classical negation). The disjunctive program can be used for two different purposes: to compute "repairs" for the database and produce consistent answers, i.e., a maximal set of atoms which do not violate the constraints. We show that our technique is sound, complete (each preferred stable model defines a repair and each repair is derived from a preferred stable model), and more general than techniques previously proposed.     

On the implication problem for cardinality constraints and functional dependencies

In database design, integrity constraints are used to express database semantics. They specify the way by that the elements of a database are associated to each other. The implication problem asks whether a given set of constraints entails further constraints. In this paper, we study the finite implication problem for cardinality constraints. Our main result is a complete characterization of closed sets of cardinality constraints. Similar results are obtained for constraint sets containing cardinality constraints, but also key and functional dependencies. Moreover, we construct Armstrong databases for these constraint sets, which are of special interest for example-based deduction in database design.     

Maintenance of implication integrity constraints under updates to constraints

Semantic integrity constraints are used for enforcing the integrity of the database as well as for improving the efficiency of the database utilization. Although semantic integrity constraints are usually much more static as compared to the data itself, changes in the data semantics may necessitate corresponding changes in the constraint base. In this paper we address the problems related with maintaining a consistent and non-redundant set of constraints satisfied by the database in the case of updates to the constraint base. We consider implication constraints as semantic integrity constraints. The constraints are represented as conjunctions of inequalities. We present a methodology to determine whether a constraint is redundant or contradictory with respect to a set of constraints. The methodology is based on the partitioning of the constraint base which improves the efficiency of algorithms that check whether a constraint is redundant or contradictory with respect to a constraint base. Received August 19, 1993 / Accepted July 7, 1997     

A Logic Based Asynchronous Multi-Agent System

We present a logic programming based asynchronous multi-agent system in which agents can communicate with one another; update themselves and each other; abduce hypotheses to explain observations, and use them to generate actions. The knowledge base of the agents is comprised of generalized logic programs, integrity constraints, active rules, and of abducibles. We characterize the interaction among agents via an asynchronous transition rule system, and provide a stable models based semantics. An example is developed to illustrate how our approach works.     

Constraint analysis: a design process for specifying operations onobjects

A design process for an object-oriented database design environment, known as constraint analysis, is presented. Given the increased level of semantics associated with an object-oriented database schema, constraint analysis makes use of semantics expressed as database constraints to support the flexible specification of propagation actions for operations on objects. Constraints are formally represented using Horn logic. The constraint analysis process then reasons about constraints at design time to help the designer understand the effects of constraints on object manipulation, identifying possible constraint violations as well as design alternatives for handling violations. An advantage of constraint analysis is that both inherent and explicit schema constraints are included in the analysis process. A formal representation is given that supports the analysis of constraints and the automatic identification of design alternatives for responding to constraint violations     

Validating database updates

Individual facts in the real world are represented by tuples in database relations (instances), while universal (time-independent) facts are treated as semantic constraints regarding database relation schemata. One important role of these semantic constraints is their use as integrity constraints that must not be violated by update operations. Among these, static constraints are represented by assertions, which are extended relational calculi in which every tuple variable is bound over a relation, and become true in a consistent database. When an update has been made on a consistent database, it is necessary to ascertain if the updated database is still consistent. It can be done by evaluating all the assertions in the updated database, but this is very time consuming. If a given assertion is in one of some classes, it is possible to devise an efficient validation procedure, which before the update is actually applied determines if the update violates the given assertion. In many cases a simplified form can be found, by examining whose value the properness of the given update is determined. The existence of such an efficient procedure and simplified form depends on what class the given assertion belongs, and also on what type of the update is to be made on what relation. This paper presents a method of finding such a procedure and simplified form using several simple syntactical transformation rules regarding extended relational calculi. This method is based on several basic properties in prepositional logic and many-sorted predicate logic.     

A three-valued semantics for querying and repairing inconsistent databases

The problem of managing and querying inconsistent databases has been deeply investigated in the last few years. As the problem of consistent query answering is hard in the general case, most of the techniques proposed so far have an exponential complexity. Polynomial techniques have been proposed only for restricted forms of constraints (such as functional dependencies) and queries. In this paper, a technique for computing “approximate” consistent answers in polynomial time is proposed, which works in the presence of a wide class of constraints (namely, full constraints) and Datalog queries. The proposed approach is based on a repairing strategy where update operations assigning an undefined truth value to the “reliability” of tuples are allowed, along with updates inserting or deleting tuples. The result of a repair can be viewed as a three-valued database which satisfies the specified constraints. In this regard, a new semantics (namely, partial semantics) is introduced for constraint satisfaction in the context of three-valued databases, which aims at capturing the intuitive meaning of constraints under three-valued logic. It is shown that, in order to compute “approximate” consistent query answers, it suffices to evaluate queries by taking into account a unique repair (called deterministic repair), which in some sense “summarizes” all the possible repairs. The so obtained answers are “approximate” in the sense that are safe (true and false atoms in the answers are, respectively, true and false under the classical two-valued semantics), but not complete.     

Abductive logic programming agents with destructive databases

In this paper we present an agent language that combines agent functionality with a state transition theory and model-theoretic semantics. The language is based on abductive logic programming (ALP), but employs a simplified state-free syntax, with an operational semantics that uses destructive updates to manipulate a database, which represents the current state of the environment. The language builds upon the ALP combination of logic programs, to represent an agent??s beliefs, and integrity constraints, to represent the agent??s goals. Logic programs are used to define macro-actions, intensional predicates, and plans to reduce goals to sub-goals including actions. Integrity constraints are used to represent reactive rules, which are triggered by the current state of the database and recent agent actions and external events. The execution of actions and the assimilation of observations generate a sequence of database states. In the case of the successful solution of all goals, this sequence, taken as a whole, determines a model that makes the agent??s goals and beliefs all true.     

Model theoretic approach to view updates in deductive databases

The view update problem for deductive databases has been defined as the problem of accomplishing the update of an intensional predicate by modifying appropriately the extensional database. A previous paper by Grant, Horty, Lobo, and Minker developed algorithms for the insertion and the deletion of an intensional predicate in certain important classes of stratified disjunctive deductive databases. This paper introduces a model theoretic approach which encompasses a wide class of Herbrand semantics, including the perfect model and stable model semantics, for disjunctive databases including negation. This generalizes the earlier results: now the intensional database may contain disjunctive and denial rules, and the database may be required to satisfy integrity constraints. As in the previous paper, the algorithms are proved to be correct and best according to the criterion of causing minimal change to the database, where the first priority is to minimize deletions.     

对象语义约束检验系统的设计和实现

我们使用一阶谓词逻辑公式表示对象的语义约束，即对象结构特片和操作行为特征约束，这些逻辑公式必须保证是一致的，并且对象在其演变的历史过程中必须满足对象约束，本文介绍一个对象语义约束检验系统。     

Generalized production rules as a basis for integrating active anddeductive databases

The authors address the problem of providing a homogeneous framework for integrating, in a database environment, active rules, which allow the specification of actions to be executed whenever certain events take place, and deductive rules, which allow the specification of deductions in a logic programming style. Actually, it is widely recognized that both kinds of rules enhance the capabilities of database systems since they provide very natural mechanisms for the management of various important activities (e.g., knowledge representation, complex data manipulation, integrity constraint enforcement, view maintenance). However, in spite of their strong relationship, little work has been done on the unification of these powerful paradigms. They present a rule-based language with an event-driven semantics that allows programmers to express both active and deductive computations. The language is based on a new notion of production rules whose effect is both a change of state and an answer to a query. By using several examples, they show that this simple language schema allows one to uniformly define different computations on data, including complex data manipulations, deductive evaluations, and active rule processing. They define the semantics of the language and then describe the architecture of a preliminary implementation of the language. Finally, they report on the application and experience of using the language     

Consistent data for inconsistent XML document

XML document may contain inconsistencies that violate predefined integrity constraints, which causes the data inconsistency problem. In this paper, we consider how to get the consistent data from an inconsistent XML document. There are two basic concepts for this problem: Repair is the data consistent with the integrity constraints, and also minimally differs from the original one. Consistent data is the data common for every possible repair. First we give a general constraint model for XML, which can express the commonly discussed integrity constraints, including functional dependencies, keys and multivalued dependencies. Next we provide a repair framework for inconsistent XML document with three basic update operations: node insertion, node deletion and node value modification. Following this approach, we introduce the concept of repair for inconsistent XML document, discuss the chase method to generate repairs, and prove some important properties of the chase. Finally we give a method to obtain the greatest lower bound of all possible repairs, which is sufficient for consistent data. We also implement prototypes of our method, and evaluate our framework and algorithms in the experiment.     

Formulating global integrity constraints during derivation of global schema

In a heterogeneous distributed database environment, each component database is characterized by its own logical schema and its own set of integrity constraints. The task of generating a global schema from a constituent local schemata has been addressed by many researchers. The complementary problem of using multiple sets of integrity constraints to create a new set of global integrity constraints is examined in this paper. These global integrity constraints facilitate both query optimization and update validation tasks.     

A procedural semantics for stratified database updates

This paper investigates efficient evaluation of database updates and presents a procedural semantics for stratified update programs that extend stratified logic programs with bulk updates and hypothetical reasoning. Bulk rules with universal quantification in the body allow an arbitrary update to be applied simultaneously for every answer of an arbitrary query. Hypothetical reasoning is supported by testing the success or failure of an update. The procedural semantics offers efficient goal-oriented tabled evaluation of database updates. It guarantees termination for function-free stratified update programs and avoids repeated computation of identical subgoals. This revised version was published online in June 2006 with corrections to the Cover Date.     

Incremental recomputation of active relational expressions

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 also be performed incrementally. An efficient algorithm for the incremental recomputation of active relational expressions based on finite differencing techniques is presented. 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     

Disjunctive LP+integrity constraints= stable model semantics

We show that stable models of logic programs may be viewed as minimal models of programs that satisfy certain additional constraints. To do so, we transform the normal programs into disjunctive logic programs and sets of integrity constraints. We show that the stable models of the normal program coincide with the minimal models of the disjunctive program thatsatisfy the integrity constraints. As a consequence, the stable model semantics can be characterized using theextended generalized closed world assumption for disjunctive logic programs. Using this result, we develop a bottomup algorithm for function-free logic programs to find all stable models of a normal program by computing the perfect models of a disjunctive stratified logic program and checking them for consistency with the integrity constraints. The integrity constraints provide a rationale as to why some normal logic programs have no stable models.     

基于免疫体系的安全数据库结构设计研究

提出了基于免疫体系的安全数据库四层结构：身份认证层,存取控制层,约束安全层,适应性检测层。并给出了约束安全层和适应性检测层的予层结构。将约束安全层分为完整性约束、分级和推理约束、访问约束和应用语义约束四个予层,将适应性检测层分为数据库活动级、关系模式级、事务级和应用语义级四个子层。构造了一个多层多级的数据库安全体系,最后给出了具体实现方案。     

Database Repairs and Analytic Tableaux

In this article, we characterize in terms of analytic tableaux the repairs of inconsistent relational databases, that is databases that do not satisfy a given set of integrity constraints. For this purpose we provide closing and opening criteria for branches in tableaux that are built for database instances and their integrity constraints. We use the tableaux based characterization as a basis for consistent query answering, that is for retrieving from the database answers to queries that are consistent with respect to the integrity constraints.