Integrity Constraint Checking Research Articles

Metadata-driven Data Migration from Object-relational Database to NoSQL Document-oriented Database

The object-relational databases (ORDB) are powerful for managing complex data, but they suffer from problems of scalability and managing large-scale data. Therefore, the importance of the migration of ORDB to NoSQL derives from the fact that the large volume of data can be handled in the best way with high scalability and availability. This paper reports our metadata-driven approach for the migration of the ORDB to document-oriented NoSQL database. Our data migration approach involves three major stages: a preprocessing stage, to extract the data and the schema's components, a processing stage, to provide the data transformation, and a post-processing stage, to store the migrated data as BSON documents. The approach maintains the benefits of Oracle ORDB in NoSQL MongoDB by supporting integrity constraint checking. To validate our approach, we developed OR2DOD (Object Relational to Document-Oriented Databases) system, and the experimental results confirm the effectiveness of our proposal.

An MDE-based methodology for closed-world integrity constraint checking in the semantic web

Ontology-based data-centric systems support open-world reasoning. Therefore, for these systems, Web Ontology Language (OWL) and Semantic Web Rule Language (SWRL) are not suitable for expressing integrity constraints based on the closed-world assumption. Thus, the requirement of integrating the open-world assumption of OWL/SWRL with closed-world integrity constraint checking is inevitable. SPARQL, recommended by World Wide Web (W3C), is a query language for RDF graphs, and many research studies have shown that it is a perfect candidate for closed-world constraint checking for ontology-based data-centric applications. In this regard, many research studies have been performed to transform integrity constraints into SPARQL queries where some studies have shown the limitations of partial expressivity of knowledge bases while performing the indirect transformations, whereas others are limited to a platform-specific implementation. To address these issues, this paper presents a flexible and formal methodology that employs Model-Driven Engineering (MDE) to model closed-world integrity constraints for open-world reasoning. The proposed approach offers semantic validation of data by expressing integrity constraints at both the model level and the code level. Moreover, straightforward transformations from OWL/SWRL to SPARQL can be performed. Finally, the methodology is demonstrated via a real-world case study of water observations data.

IMPLEMENTING TOPOLOGICAL INTEGRITY CONSTRAINTS ON TEMPORAL DATABASES

Checking integrity constraints in real-time the database is an important field of investigation. In this paper, we implement topological integrity constraints depending on which user has chosen an integrity constraint on different times on many existing integrity constraints of temporal databases. We suggested using the Hamiltonian paths in directed graphs order to implement a test program on data simulated by a college's real data. The object needs to satisfy integrity constraints in temporal databases as students who have enrolled in the subjects. Moreover, the program also monitors the learning process and advises students to choose courses in the school's training program.

CHECKING OF CONCEPTUAL MODELS WITH INTEGRITY CONSTRAINTS

Due to the raising level of abstraction in information systems development many activities of this process are migrating to its early phases. The same is true for testing – modern CASE tools are undertaking validation of software models. In this paper the methodology for checking of conceptual models is proposed as the step-wise pro-cess during which model elements including integrity constraints are progressively checked for their adequacy to values of objects, their relationships and constraints of the corresponding problem domain. The checking process is associated with the particular methodology for development of ordered and precise conceptual models (OPCM), which brings improvements to their quality: conformity to normal forms and ontological foundations, and to the observed reality. The rules for checking of integrity constraints are proposed on the base of taxonomy created in the result of analysis of the most promising methods for conceptual modelling.

A Framework for Checking and Ranking Integrity Constraints in a Distributed Database

The essential aim of a database system is to guarantee database consistency, which means that the data contained in a database is both accurate and valid. Checking the consistency of a database state generally involves the execution of integrity tests (query that returns the value true or false) on the database, which verify whether the database is satisfying its constraints or not. The process of checking integrity constraints has proved to be extremely difficult to implement, particularly in distributed database. This paper proposed a framework for checking integrity constraints in a distributed database by utilizing as much as possible the local information stored at the target site. The proposed framework consists of two main processes, namely: (i) simplify the integrity constraints to produce support tests and integrate them with complete and sufficient tests and (ii) select the most suitable test from several alternative tests when an update operation is submitted to the system. Including these processes in the proposed framework has optimized the process of checking the consistency of the distributed database by reducing the amount of data transferred across the network, the amount of data accessed, the number of sites involved, and the number of integrity constraints to be evaluated.

3-L Model: A Model for Checking the Integrity Constraints of Mobile Databases

In this paper we propose a model for checking integrity constraints of mobile databases called Three-Level (3-L) model, wherein the process of constraint checking to maintain the consistent state of mobile databases is realized at three different levels. Sufficient and complete tests proposed in the previous works together with the idea of caching relevant data items for checking the integrity constraints are adopted. This has improved the checking mechanism by preventing delays during the process of checking constraints and performing the update. Also, the 3-L model reduces the amount of data accessed given that much of the tasks are performed at the mobile host, and hence speeds up the checking process.

A Framework for Caching Relevant Data Items for Checking Integrity Constraints of Mobile Database

In a mobile environment, due to the various constraints
 inherited from limitations of wireless communication
 and mobile devices, checking for integrity constraints to
 maintain the consistent state of mobile databases is an important
 issue that needs to be addressed. Hence, in this paper
 we propose a framework for caching relevant data items
 needed during the process of checking integrity constraints
 of mobile databases. This is achieved by analyzing the relationships
 among the integrity tests (simplified form of integrity
 constraints) to be evaluated for a given update operation.
 This improves the checking mechanism by preventing
 delays during the process of checking constraints and performing
 the update. Hence, our model speeds up the checking
 process.

Improved Integrity Constraints Checking in Distributed Databases by Exploiting Local Checking

Most of the previous studies concerning checking the integrity constraints in distributed database derive simplified forms of the initial integrity constraints with the sufficiency property, since the sufficient test is known to be cheaper than the complete test and its initial integrity constraint as it involves less data to be transferred across the network and can always be evaluated at the target site (single site). Their studies are limited as they depend strictly on the assumption that an update operation will be executed at a site where the relation specified in the update operation is located, which is not always true. Hence, the sufficient test, which is proven to be local test by previous study, is no longer appropriate. This paper proposes an approach to checking integrity constraints in a distributed database by utilizing as much as possible the local information stored at the target site. The proposed approach derives support tests as an alternative to the existing complete and sufficient tests proposed by previous researchers with the intention to increase the number of local checking regardless the location of the submitted update operation. Several analyses have been performed to evaluate the proposed approach, and the results show that support tests can benefit the distributed database, where local constraint checking can be achieved.

Integrity Constraint Checking in Distributed Nested Transactions over a Database Cluster


 
 
 This paper presents a solution to check referential integrity constraints and conjunctive global constraints in a relational multi database system. It also presents the experimental results obtained by implementing this solution over a PC cluster with Oracle9i DBMS.
 The goal of those experimentations is to measure the time spent to check global constraints in a distributed systems. The results show that the overhead induced by our distributed constraint checking is reduced by 50% compared to a centralized checking of constraints.
 
 

On the abductive or deductive nature of database schema validation and update processing problems

We show that database schema validation and update processing problems such as view updating, materialized view maintenance, integrity constraint checking, integrity constraint maintenance or condition monitoring can be classified as problems of either abductive or deductive nature, according to the reasoning paradigm that inherently suites them. This is done by performing abductive and deductive reasoning on the event rules (Olive 1991), a set of rules that define the difference between consecutive database states. In this way, we show that it is possible to provide methods able to deal with all these problems as a whole. We also show how some existing general deductive and abductive procedures may be used to reason on the event rules. In this way, we show that these procedures can deal with all database schema validation and update processing problems considered in this paper.

Minimal model generation for refined answering of generalized queries in disjunctive deductive databases

Generalized queries are defined as sets of clauses in implication form. They cover several tasks of practical importance for database maintenance such as answering positive queries, computing database completions and integrity constraints checking. We address the issue of answering generalized queries under the minimal model semantics for the class of disjunctive deductive databases (DDDBs). The advanced approach is based on having the query induce an order on the models returned by a sound and complete minimal model generating procedure. We consider answers that are true in all and those that are true in some minimal models of the theory. We address the issue of answering positive queries through the construction of the minimal model state of the DDDB, using a minimal model generating procedure. The refinements allowed by the procedure include isolating a minimal component of a disjunctive answer, the specification of possible updates to the theory to enable the derivability of certain queries and deciding the monotonicity properties of answers to different classes of queries.

Computing abduction by using TMS with top-down expectation

We present a method to compute abduction in logic programming. We translate an abductive framework into a normal logic program with integrity constraints and show the correspondence between generalized stable models and stable models for the translation of the abductive framework. Abductive explanations for an observation can be found from the stable models for the translated program by adding a special kind of integrity constraint for the observation. Then, we show a bottom-up procedure to compute stable models for a normal logic program with integrity constraints. The proposed procedure excludes the unnecessary construction of stable models on early stages of the procedure by checking integrity constraints during the construction and by deriving some facts from integrity constraints. Although a bottom-up procedure has the disadvantage of constructing stable models not related to an observation for computing abductive explanations in general, our procedure avoids the disadvantage by expecting which rule should be used for satisfaction of integrity constraints and starting bottom-up computation based on the expectation. This expectation is not only a technique to scope rule selection but also an indispensable part of our stable model construction because the expectation is done for dynamically generated constraints as well as the constraint for the observation.

Three types of redundancy in integrity checking: An optimal solution

Known methods for checking integrity constraints in deductive databases do not eliminate all aspects of redundancy in integrity checking. By making the redundancy aspects of integrity constraint checking explicit, independently from any chosen method, it is possible to develop a new method that is optimal with respect to the classified redundancy aspects. We distinguish three types of redundancy and propose an integrity checking method based on revised inconsistency rules.

Processing production rules in DEVICE, an active knowledge base system

Production rules are useful for several tasks in active database systems, such as integrity constraint checking, derived data maintenance, database state monitoring, etc. Furthermore, production rules can express knowledge in a high-level form for problem solving in Knowledge Base Systems (KBS). Present active object-oriented database (OODB) systems traditionally provide event-driven rules which are triggered by events, i.e. database modifications. This paper describes DEVICE, a high-level rule integration scheme in an active OODB system, resulting in an active KBS. The paper emphasises the run-time processing of production rules, namely the incremental matching of rule conditions, as well as rule selection and firing. The matching of production rules requires special algorithms based on the flow of updated data through a discrimination network, like RETE, TREAT, etc. DEVICE offers a smooth integration of production rules into an active OODB system that only supports event-driven rules, without introducing new data structures, maintaining at the same time the properties of discrimination networks. This is achieved using complex events to map the conditions of production rules and monitor the database to incrementally match those conditions. DEVICE maps each production rule into one event-driven rule that is easy to maintain and offers centralised rule selection control for correct run-time behaviour and conflict resolution. Furthermore, DEVICE provides the infrastructure for the integration of various other rule paradigms into a single KBS, like deductive rules and integrity constraints and leaves room for the optimisation of the matching process through variations of the basic discrimination network.

Protocols for Integrity Constraint Checking in FederatedDatabases

A federated database is comprised of multiple interconnected database systems that primarily operate independently but cooperate to a certain extent. Global integrity constraints can be very useful in federated databases, but the lack of global queries, global transaction mechanisms, and global concurrency control renders traditional constraint management techniques inapplicable. This paper presents a threefold contribution to integrity constraint checking in federated databases: (1) The problem of constraint checking in a federated database environment is clearly formulated. (2) A family of protocols for constraint checking is presented. (3) The differences across protocols in the family are analyzed with respect to system requirements, properties guaranteed by the protocols, and processing and communication costs. Thus, our work yields a suite of options from which a protocol can be chosen to suit the system capabilities and integrity requirements of a particular federated database environment.

Materialized view maintenance and integrity constraint checking

We investigate the problem of incremental maintenance of an SQL view in the face of database updates, and show that it is possible to reduce the total time cost of view maintenance by materializing (and maintaining) additional views. We formulate the problem of determining the optimal set of additional views to materialize as an optimization problem over the space of possible view sets (which includes the empty set). The optimization problem is harder than query optimization since it has to deal with multiple view sets, updates of multiple relations, and multiple ways of maintaining each view set for each updated relation.We develop a memoing solution for the problem; the solution can be implemented using the expression DAG representation used in rule-based optimizers such as Volcano. We demonstrate that global optimization cannot, in general, be achieved by locally optimizing each materialized subview, because common subexpressions between different materialized subviews can allow nonoptimal local plans to be combined into an optimal global plan. We identify conditions on materialized subviews in the expression DAG when local optimization is possible. Finally, we suggest heuristics that can be used to efficiently determine a useful set of additional views to materialize.Our results are particularly important for the efficient checking of assertions (complex integrity constraints) in the SQL-92 standard, since the incremental checking of such integrity constraints is known to be essentially equivalent to the view maintenance problem.

Computer support for protocol-based treatment of cancer

Cancer treatment is often carried out within protocol-based clinical trials. An oncology clinic may take part in many trials each of which requires data to be collected for monitoring efficacy and toxicity of treatment. Subsequently, these data are analyzed statistically to evaluate clinical objectives of the trial. To be scientifically valid, such analysis must be based on data that are both complete and correct. This is one motivating factor for introducing computer support for trial management. Further motivation is provided by concern that treatment is consistent with the protocl and the well-being of the patient. The complexity of many protocols, the life-threatening nature of cancer, and the toxicity of treatment side effects emphasize the safety-critical nature of oncology. The OaSiS system provides decision support for the protocol- based treatment of cancer patients with emphasis on the safety aspects of the advice it gives. It offers a graphical and spreadsheet-style interface, employs integrity constraint checking techniques from logic database to monitor compliance with a protocol, and is implemented in PROLOG. This paper describes the main features of OaSiS and indeicates work in progress and planned research.

A new method for integrity constraint checking in deductive databases

An update of a consistent database can influence the integrity of the database. The available integrity checking methods in deductive databases are often criticized for their lack of efficiency. The main goal of this paper is to present a new integrity checking method which does not have some of the disadvantages of existing methods. The main advantage of the proposed method is that the integrity check is performed primarily at compile time. In order to demonstrate the improvement in efficiency of the proposed method it was compared both fundamentally and experimentally with existing methods.

Intelligent database caching through the use of page-answers and page-traces

In this paper a new method to improve the utilization of main memory systems is presented. The new method is based on prestoring in main memory a number of query answers, each evaluated out of a single memory page. To this end, the ideas of page-answers and page-traces are formally described and their properties analyzed. The query model used here allows for selection, projection, join, recursive queries as well as arbitrary combinations. We also show how to apply the approach under update traffic. This concept is especially useful in managing the main memories of an important class of applications. This class includes the evaluation of triggers and alerters, performance improvement of rule-based systems, integrity constraint checking, and materialized views. These applications are characterized by the existence at compile time of a predetermined set of queries, by a slow but persistent update traffic, and by their need to repetitively reevaluate the query set. The new approach represents a new type of intelligent database caching, which contrasts with traditional caching primarily in that the cache elements are derived data and as a consequence, they overlap arbitrarily and do not have a fixed length. The contents of the main memory cache are selected based on the data distribution within the database, the set of fixed queries to preprocess, and the paging characteristics. Page-answers and page-traces are used as the smallest indivisible units in the cache. An efficient heuristic to select a near optimal set of page-answers and page-traces to populate the main memory has been developed, implemented, and tested. Finally, quantitative measurements of performance benefits are reported.

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