Enforcement Of Integrity Constraints Research Articles

Temporal data modelling and integrity constraints in relational databases*

There are key issues in temporal relational data modelling such as representation of temporal data, temporal grouping identifiers, primary keys of temporal relations and temporal integrity constraints. Temporal grouping is a fundamental aspect of temporal data modelling and is the basis for the specification and enforcement of temporal integrity constraints. We extend and generalize traditional integrity constraints for the temporal domain by formally defining the temporal grouping identifier and show how it can replace a temporal primary key like a temporal atom, a temporal integrity constraint has a data and a temporal component. We also introduce the notion of consistent evolution of a temporal database that lays the foundation for an efficient implementation of temporal integrity constraints. We also provide clauses that need to be added to SQL for specifying the temporal integrity constraints.

FLASc: a formal algebra for labeled property graph schema

Contemporary labeled property graph databases are either schema-less or schema-optional to support frequent changes in the structure of data found in domains requiring high flexibility. However, the lack of structure impacts data transformation and loading operations from heterogeneous sources into graph databases. We present a formal algebra FLASc for specifying and generating graph schema for labeled property graph databases. We formally define FLASc and demonstrate the use of FLASc generated graph schemas to systematically transform and load data-sets related to domains of cyber-physical systems, big data analytics and tourism. Findings from three disparate case studies show that FLASc-generated schemas assist in enforcing integrity constraints that reduce the chance of data corruption, hence assuring data consistency and integrity.

Embedding reactive behavior into artifact-centric business process models

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.

A NOTE ON PROCESS MODELLING: COMBINING SITUATION CALCULUS AND PETRI NETS

The situation calculus logic model is convenient for modelling the actions that can occur in an information system application. The interplay of pre-conditions and post-conditions determines a semantically justified partial order of the defined actions and serves to enforce integrity constraints. This form of specification allows the use of plan-generation algorithms to investigate, before the system is adopted, whether the proposed specification allows all desirable use cases, and effectively disallows undesirable ones. Especially for legacy applications, implemented without a prior specification, Process Mining techniques were employed to derive an implicit Petri net model from the analysis of a large number of traces registered in an execution log. However, if the system just begins to be used, and has a still empty execution log, this sort of process mining discovery would not be feasible. This paper explains how the Petri net model can be directly derived from the situation calculus specification rules. The main gist is to provide evidence that the two models are complementary, not only because the Petri net model is derivable from the situation calculus model, but also in view of the distinct advantages of the two models. While the situation calculus model leads to planning and simulated execution prior to implementation, the Petri net model can be designed to run in a restrictive mode, allowing an intuitive visualization of the workable sequences. As proof of concept, the paper describes a prototype to demonstrate the methods and applies it to two examples: a published request processing application used to introduce process mining notions; and an analogously structured trial by combat application taken from a popular movie. The prototype includes an interactive dramatization component, which enacts the second application.

Comparison of Post-Relational and Object-Relational modelling for real-world database applications

Purpose – The purpose of this paper is to compare the use of two Object-Relational models against the use of a post-Relational model for a realistic application. Although real-world applications, in most cases, can be adequately modeled by the Entity-Relationship (ER) model, the transformation to the popular Relational model alters the representation of structures common in reality, like multi-valued and composite fields. Alternative database models have been developed to overcome these shortcomings. Design/methodology/approach – Based on the ER model of a medical application, this paper compares the information representation, manipulation and enforcement of integrity constraints through PostgreSQL and Oracle, against the use of a post-Relational model composed of the Conceptual Universal Database Language (CUDL) and the Conceptual Universal Database Language Abstraction Level (CAL). Findings – The CAL/CUDL pair, although more periphrastic for data definition, is simpler for data insertions, does not require the use of procedural code for data updates, produces clearer output for retrieval of attributes, can accomplish retrieval of rows based on conditions that address composite data with declarative statements and supports data validation for relationships between composite data without the need for procedural code. Research limitations/implications – To verify, in practice, the conclusions of the paper, complete implementation of a CAL/CUDL system is needed. Practical implications – The use of the CAL/CUDL pair would advance the productivity of database application development. Originality/value – This paper highlights the properties of realistic database-applications modelling and management that are desirable by developers and shows that these properties are better satisfied by the CAL/CUDL pair.

Service Constraint Guarantees

In this paper we investigate the problem of providing consistency, availability and durability for Web Service transactions. We consider enforcement of integrity constraints in a way that increases the availability while guaranteeing the correctness specified in the constraint. We study hierarchical constraints that offer an opportunity for optimization because of an expensive aggregation calculation required in the enforcement of the constraint. We propose an approach that guarantees enforcement of constraints and also allow the distribution of write operations among many clusters to increase the availability. In our previous work, we proposed a replica update propagation method, called the Buddy System, which guaranteed durability and increased availability of web services. In this paper, we extend the Buddy System to enforce hierarchical data integrity constraints. En terprise web-based transaction systems need to support many concurrent clients simultaneously accessing shared resources. These applications are often developed using a Service Oriented Architecture (SOA). SOA supports the composition of multiple Web Services (WSs) to perform complex business processes. One of the important aspects for SOA applications is to provide a high-level of concurrency; we can think of the measure of the concurrency as the availability of the service to all clients requesting services. A common way to increase the availability is through the replication of the services and their corresponding resources. Often a web farm is used to host multiple replicas of the web application, web services and their resources. Requests are distributed among the replicas. Consistency and durability are often sacrificed to achieve increased availability. The CAP theory [1] [2], stating that distributed database designers can achieve at most two of the properties: consistency (C), availability (A), and partition tolerance (P), has influenced distributed database design in a way that often causes the designer to give up on immediate consistency. In our previous papers we have addressed issues related to increasing availability while still guaranteeing durability and consistency of replicated databases. In this paper we address issues related to maintaining high availability while adding guarantees of correctness by enforcing hierarchical constraints. Traditionally these hierarchical constraints are not enforced by the system due to the expensive run-time cost. In our previous work [3] [4] we provided an extension to the lazy replica update propagation method to reduce the risk of data loss and provide high availability while maintaining consistency. The Buddy System executes a transaction on a primary replica. However, the transaction cannot commit until a secondary replica, “the buddy”, also preserves the effects of the transaction. The rest of the replicas are updated using one of the standard lazy update propagation protocols. The Buddy System provides a guarantee of transactional durability (i.e., effects of the transaction are preserved even if the server, hosting the primary replica crashes before the update can be propagated to the other replicas) and efficient update propagation (i.e., our approach requires the synchronized update between two replicas only, therefore adding minimal overhead to the lazy-replication protocol). The Buddy System uses an application-layer dispatcher [5] to select the buddies based on the data items and the operations of the transactions, the data versions available, and the network characteristics of the WS farm. A limitation of the Buddy System is that integrity constraints that require different classes in the calculation cannot be guaranteed. An example is an address that requires a valid owner in the person class. This integrity constraint cannot be enforced because data mutation can happen on different clusters simultaneously. In this paper we address this limitation. We provide an approach that pulls the Unified Markup Language (UML) constraints expressed in Object Constraint Language (OCL) from the design model. Data is incrementally maintained to allow the dispatcher to enforce the constraint, and, once successful, distribute the requests to several clusters concurrently.

Checking enforcement of integrity constraints in database applications based on code patterns

Integrity constraints (including key, referential and domain constraints) are unique features of database applications. Integrity constraints are crucial for ensuring accuracy and consistency of data in a database. It is important to perform integrity constraint enforcement (ICE) at the application level to reduce the risk of database corruption. We have conducted an empirical analysis of open-source PHP database applications and found that ICE does not receive enough attention in real-world programming practice. We propose an approach for automatic detection of ICE violations at the application level based on identification of code patterns. We define four patterns that characterize the structures of code implementing integrity constraint enforcement. Violations of these patterns indicate the missing of integrity constraint enforcement. Our work contributes to quality improvement of database applications. Our work also demonstrates that it is feasible to effectively identify bugs or problematic code by mining code patterns in a specific domain/application area.

Maintaining control while delegating trust

We introduce the use, monitoring, and enforcement of integrity constraints in trust management-style authorization systems. We consider what portions of the policy state must be monitored to detect violations of integrity constraints. Then, we address the fact that not all participants in a trust-management system can be trusted to assist in such monitoring, and show how many integrity constraints can be monitored in a conservative manner so that trusted participants detect and report if the system enters a policy state from which evolution in unmonitored portions of the policy could lead to a constraint violation.

A Comparison of the Universal and the Regular Database Design.

Abstract. It is tempting to a database according to very abstracts concepts in order to cope with changing requirements. generic which is called database design, allows us to record all possible facts in terms of object types, objects, attributes, attribute values, and relationships. Arguably this kind of simplifies the recording of new kinds of facts. However, the has many associated problems. In this paper, we introduce a framework for evaluating database designs. We present the analysis of some of the advantages and disadvantages of the use of the universal by using the framework. Keywords. database data management, universal SQL Introduction Two important properties of the system development methodologies of the Internet time are constant time pressure to the developers and vague requirements that often change [1]. One tempting solution for dealing with changing requirements to databases seems to be the use of a highly generic database that has different names and variations: Data Model [2], The entity-attribute-value representation with classes and relationships (EAV/CR) [3], Generic data model [4], and vertical design [5]. However, ease of evolution is not the only aspect that we must consider in case of selecting a suitable database design. In addition, if we consider ease of evolution, then we must also consider how we can enforce integrity constraints. goal of the paper is to introduce a framework for evaluating database designs and analyse some of the advantages and disadvantages of the use of the universal design. This analysis is based on the experiments and the results of a literature review. Existing studies consider only few disadvantages and provide few experimental results. In this paper, we extend the work that was started in [6]. We use the concepts of SQL [7] because existing literature about the universal uses these concepts. rest of the paper is organized as follows. Firstly, we explain the principles of the universal design. Secondly, we introduce a framework for evaluating database designs. Thirdly, we analyze some advantages and disadvantages of the use of this design. Finally, we draw conclusions and point to the future work. 1. Universal Design part a) of Figure 1 is pictorial representation of the universal design. part b) of Figure 1 presents an example of the regular design. It is also possible to use a

Management of business process constraints using BPTrigger

This paper proposes a new mechanism, called BPTrigger, which can overcome limitations of current Database (DB) Triggers. DB Triggers are used to enforce integrity constraints related to data stored in databases. They are not adequate, however, for complex business constraints that must be applied to several business processes or activities, hence, involving many data items. Further, DB Triggers does not properly support distributed and heterogeneous environments and may incur serious performance degradation including non-termination. BPTrigger enables representation and flexible enforcement of complex business process constraints in a distributed and heterogeneous environment. Unlike a DB Trigger that must be defined on each data item participating in a constraint and must be checked every time the data item is updated, BPTrigger allows a constraint to be defined only once on a business process and enforces the constraint once at the time of execution of the process. To provide comprehensive support, the paper identifies all possible constraints related to business processes based on literature survey and classifies them into four types: entry, exit, running, and invariant, according to the time of enforcement. Reflecting the requirements suggested by the classification, the syntax of BPTrigger is defined. An additional construct is proposed to enable flexible management of invariants. The paper also introduces a prototype system for BPTrigger along with an extended example to demonstrate its feasibility and to provide a performance comparison with typical DB Triggers.

A Structure-Oriented Product Data Representation of Engineering Changes for Supporting Integrity Constraints

This paper proposes a product data representation that can express and enforce integrity constraints on product structure during engineering changes (ECs). The representation adopts and extends the structure-oriented approach for managing EC data. Tightly integrated with product structure, it will enable designers to maintain and exchange consistent EC data throughout the product life cycle. To support operations for ECs properly, the representation provides the data, operations, and event-condition-action rules for nested ECs and simultaneous EC application to multiple options. In addition, the EC objects proposed in the representation integrate the data and integrity constraints into a unified repository. This repository will enable designers to access all EC data and integrity constraints through the product structure and relationships between EC objects. The paper also describes a prototype product data management system based on the proposed representation to demonstrate its effectiveness.

Realizing active data warehouses with off‐the‐shelf database technology

AbstractActive data warehouses belong to a new category of decision support systems, which automate decision making for routine decision tasks and semi‐routine decision tasks. Just as active database systems extend conventional database systems with event–condition–action rules for integrity constraint enforcement or procedure execution, active data warehouses extend conventional data warehouses with analysis rules that mimic the work of an analyst during decision making. This paper demonstrates how analysis rules can be implemented on top of a passive relational data warehouse system by using commercially available database technology. Copyright © 2002 John Wiley & Sons, Ltd.

The impact of next generation XML

Over the past few years, business‐to‐business (B2B) e‐commerce has grown exponentially. To conduct B2B e‐commerce, companies need a common language. HTML is not suited for this task, because it defines only the information’s format instead of its meaning. XML has been shown to not only be the most natural evolution of Web technologies to support modern applications such as e‐commerce, but also be the preferred means of making legacy data available to users via the Internet. Since XML is still in its infancy, early versions of XML do not include the fundamental feature of specifying and enforcing integrity constraints, which is critical to making XML a viable and long‐term approach for representing data over the Web. In other words, XML provides little support to make sure the data being represented satisfy the business rules specified. Reviews the trends in B2B e‐commerce and discusses the critical needs to support constraints and the integrity of data, which are very important to the success of B2B e‐commerce. Also presents the next generation of XML technology for representing constraints. Concludes with a summary of the impact of the new XML on B2B e‐commerce and its future challenges.

A navigational data model for object modeling technique development environment

Extant tools supporting Object Modeling Technique (OMT) have a serious drawback that they fail to capture a lot of relationships inherently existing among design objects. This drawback may not only disallow designers to freely navigate the relationships but also make it difficult to automatically enforce integrity constraints derived from the relationships. To overcome the drawback, we propose a navigational data model called FONASSE (FOur-dimensional NAvigation Spaceship for Software Engineering). The data model captures four structural relationships among design objects: part of, the other development stage of, the other representation of, and ersion of. A considerable part of structural semantics the design objects inherently have, can be well captured with the relationships. Since the four relationships are mutually exclusive with each other, designers may navigate a set of design objects in a four-dimensional space. Supporting the relationships at system level also entails the automatic enforcement of corresponding integrity constraints. We identified four integrity constraints, each of which is derived from one of the four relationships. In this paper, FONASSE is fully developed as a model suitable to the four-dimensional navigation. As a first step towards such development, a navigation function is defined to formally specify the semantics of queries related with the navigation. The queries, which turn out to be a specification of navigation paths, can be uniformly formulated by the combination of the navigation functions. The integrity constraints corresponding to the relationships are also expressed in terms of the navigation functions. Finally, we provide a scenario to explain the navigational characteristic of our model.

Generalized production rules as a basis for integrating active and deductive 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.

A prototype rule-based front end expert system for integrity enforcement in relational data bases: An application to the naval aircraft flight records data base

An important goal of any data base system is to model the real world accurately in a manner consistent with the user's perception of the data. One way to accomplish the accuracy of information in relational data bases is through the enforcement of integrity constraints that represent rules pertaining to the organization. Unfortunately, most DBMSs today do not provide adequate integrity features to ensure the accuracy of data in their databases. This paper discusses the design and implementation of a prototype rule-based front end expert system for integrity enforcement for the Naval Aircraft Flight Record relational data base. The expert system includes a set of rules that define (a) the update operation that triggers the testing of an integrity rule, (b) a specification of the condition to be tested, and (c) the action to be taken in case of attempted violation. These rules are stored in a knowledge base, which the inference engine of the expert system uses to enforce data base integrity.

A graph-based data model and its ramifications

Currently, database researchers are investigating new data models in order to remedy the deficiencies of the flat relational model when applied to nonbusiness applications. Herein we concentrate on a recent graph based data model called the hypernode model. The single underlying data structure of this model is the hypernode which is a digraph with a unique defining label. We present in detail the three components of the model, namely its data structure, the hypernode, its query and update language, called HNQL, and its provision for enforcing integrity constraints. We first demonstrate that the said data model is a natural candidate for formalising hypertext. We then compare it with other graph based data models and with set based data models. We also investigate the expressive power of HNQL. Finally, using the hypernode model as a paradigm for graph based data modelling, we show how to bridge the gap between graph based and set based data models, and at what computational cost this can be done.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

An overview of production rules in database systems

AbstractDatabase researchers have recognized that integrating a production rules facility into a database system provides a uniform mechanism for a number of advanced database features including integrity constraint enforcement, derived data maintenance, triggers, protection, version control, and others. In addition, a database system with rule processing capabilities provides a useful platform for large and efficient knowledge-base and expert systems. Database systems with production rules are referred to asactive database systems, and the field of active database systems has indeed been active. This paper summarizes current work in active database systems, and suggests future research directions. Topics covered include database rule languages, rule processing semantics, and implementation issues.

Semantic Integrity Considerations for Effective Data Management: Important Issues for the Database Course

Semantic integrity constraints are time invariant properties of the world of interest being represented by a database. They constrain the values that may appear in a valid database instance. Despite their crucial role in data modeling, support for them has been largely ignored by database management system (DBMS) vendors. As a result, in most database applications today, either integrity constraints are not enforced resulting in database instances that are not reflections of reality, or precious programmer time is spent in specifying and enforcing integrity constraints as application program logic. Neither of the two situations are acceptable. This article calls for a more systematic coverage of semantic integrity constraints in the database course with the intent of training informed users who can voice their discontent and put pressure on the DBMS vendors to correct the current direction.

A software tool for modular database design

A modularization discipline for database schemas is first described. The dicipline incorporates both a strategy for enforcing integrity constraints and a tactic for organizing large sets of database structures, integrity constraints, and operations. A software tool that helps the development and maintenance of database schemas modularized according to the discipline is then presented. It offers a user-friendly interface that guides the designer through the various stages of the creation of a new module or through the process of changing objects of existing modules. The tool incorporates, in a declarative style, a description of the design and redesign rules behind the modularization discipline, hence facilitating the incremental addition of new expertise about database design.