Database Integrity Constraints Research Articles

Discovering Functional Dependencies through Hitting Set Enumeration

Functional dependencies (FDs) are among the most important integrity constraints in databases. They serve to normalize datasets and thus resolve redundancies, they contribute to query optimization, and they are frequently used to guide data cleaning efforts. Because the FDs of a particular dataset are usually unknown, automatic profiling algorithms are needed to discover them. These algorithms have made considerable advances in the past few years, but they still require a significant amount of time and memory to process datasets of practically relevant sizes. We present FDHits, a novel FD discovery algorithm that finds all valid, minimal FDs in a given relational dataset. FDHits is based on several discovery optimizations that include a hybrid validation approach, effective hitting set enumeration techniques, one-pass candidate validations, and parallelization. Our experiments show that FDHits, even without parallel execution, has a median speedup of 8.1 compared to state-of-the-art FD discovery algorithms while using significantly less memory. This allows the discovery of all FDs even on datasets that could not be processed by the current state-of-the-art.

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.

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.

Integrity constraints in graph databases

Abstract: One thing that is still being developed for graph databases is integrity constraint (IC) support. One possibility to IC proposal is to consider a graph conceptual schema and a graph database schema. At least inherent ICs coming from a graph conceptual schema should be considered as explicit ICs on the graph databases level, i.e., using a DDL. In the paper, we focus on graph database Neo4j and its possibilities to express a database schema and ICs. We extend these possibilities through new constructs in Neo4j DDL including their prototype implementation and experiments.

Analysing inconsistent information using distance-based measures

There have been a number of proposals for measuring inconsistency in a knowledgebase (i.e. a set of logical formulae). These include measures that consider the minimally inconsistent subsets of the knowledgebase, and measures that consider the paraconsistent models (3 or 4 valued models) of the knowledgebase. In this paper, we present a new approach that considers the amount by which each formula has to be weakened in order for the knowledgebase to be consistent. This approach is based on ideas of knowledge merging by Konienczny and Pino-Perez. We show that this approach gives us measures that are different from existing measures, that have desirable properties, and that can take the significance of inconsistencies into account. The latter is useful when we want to differentiate between inconsistencies that have minor significance from inconsistencies that have major significance. We also show how our measures are potentially useful in applications such as evaluating violations of integrity constraints in databases and for deciding how to act on inconsistency.

Improving Data Consistency in Production Control

Under volatile market conditions, manufacturing companies, which achieve a high adherence to promised delivery dates, possess a considerable advantage over their direct competitors. However, due to dynamically changing production circumstances, this logistical target is rather hard to reach. Excellent production planning and control (PPC) processes are a main prerequisite for managing inevitable turbulences which occur in every production system and which impede to follow through with detailed scheduled production plans. An often overlooked reason for deviations between the originally planned and actually realized production program is the inadequate data quality of master and transaction data. PPC processes such as detailed scheduling, production control and production monitoring rely heavily on a vast volume of data in order to update short-term production plans, derive conclusions for ad-hoc control interventions and monitor resources’ efficiency as well as production job statuses. Typical techniques for dealing with inadequate data quality in the business context involve implementing integrity constraints in databases and defining data quality processes for the whole organization. Evidently, these classic approaches are not successfully preventing manufacturing companies from dealing with inadequate data quality in PPC processes. This paper presents a new approach for mitigating the negative effects of deficient data quality in production control by adapting data mining (DM) algorithms in order to estimate probable values for typical data inconsistencies in data relevant for production control. The algorithms are tested on a real-world data set of a typical mid-sized manufacturing company and their capability of retrieving the correct values is quantified.

Improving Data Consistency in Production Control by Adaptation of Data Mining Algorithms

Manufacturing companies are increasingly exposed to volatile market conditions. In this environment, ensuring a reliable adherence to promised delivery dates, allows for a considerable competitive advantage. However, due to dynamically changing production circumstances and high varieties in production programs, manufacturing companies regularly fail in reaching this logistical target. A main prerequisite for mastering this challenge are excellent Production Planning and Control processes. The quality of transactional data of production processes are a commonly ignored root cause for inadequate detailed scheduling plans although a vast volume of these data are used for updating production job statuses and short-term production plans, deriving conclusions for immediate control interventions as well as monitoring production efficiency. Typically, measures for improving data quality involve implementing integrity constraints in databases and setting up data quality processes as well as dedicated organizational structures. Evidently, these classic approaches do not successfully prevent manufacturing companies from dealing with inadequate data quality in their PPC processes. Consequently, this paper presents a model for increasing the quality of data relevant for production processes by adapting data mining algorithms. This new approach allows to estimate probable values for typical data inconsistencies in transactional data of PPC processes. Several adapted algorithms are benchmarked on real-world data sets of German mid-sized manufacturing companies and evaluated towards their power and efficiency.

Employing finite-state machines in data integrity problems

This paper explores the issue of group integrity of tuple subsets regarding corporate integrity constraints in relational databases. A solution may be found by applying the finite-state machine theory to guarantee group integrity of data. We present a practical guide to coding such an automaton. After creating SQL queries to manipulate data and control its integrity for real data domains, we study the issue of query performance, determine the level of transaction isolation, and generate query plans.

The metric space of the database state

The concept of homogeneous integrity constraints in database systems is introduced. The metric space for the state of database schemes with homogeneous integrity constraints is established. It is shown that many common integrity constraints that are used in practice satisfy the condition of homogeneity of integrity constraints. Such constraints include key, referential, joint, and many-to-many integrity constraints, etc. The proposed constructs allow one to design metric spaces for the state of database schemes and enable the study of integrity constraints of databases based on the methods and concepts of "continuous mathematics."

Enforcing a semantic schema to assess and improve the quality of knowledge resources

Modern Information and Communication Technologies ICT require very accurate and up-to-date knowledge resources, such as databases and knowledge bases, providing information about real-world entities e.g. locations, persons, events which can guarantee that results of automatic processing can be trusted enough for decision-making processes. The solutions employed so far to guarantee their quality mainly rely on the automatic application of integrity constraints for databases and consistency checks for knowledge bases. In order to achieve a higher accuracy, there is also a recent trend in complementing automatic with manual checks, via crowdsourcing techniques. This paper presents a methodology and an evaluation framework, based on the definition and application of a semantic schema, which analyses the sometimes hidden semantics of the terms in the entity descriptions from a knowledge resource, and allows assessing its quality and the identification of those potentially faulty parts which would benefit from manual checks. The approach is particularly suited for schema-less resources, i.e. resources in which entities do not follow a unique and explicit schema. Our evaluation showed promising results.

Interval-based temporal functional dependencies: specification and verification

In the temporal database literature, every fact stored in a database may be equipped with two temporal dimensions: the valid time, which describes the time when the fact is true in the modeled reality, and the transaction time, which describes the time when the fact is current in the database and can be retrieved. Temporal functional dependencies (TFDs) add valid time to classical functional dependencies (FDs) in order to express database integrity constraints over the flow of time. Currently, proposals dealing with TFDs adopt a point-based approach, where tuples hold at specific time points, to express integrity constraints such as "for each month, the salary of an employee depends only on his role". To the best of our knowledge, there are no proposals dealing with interval-based temporal functional dependencies (ITFDs), where the associated valid time is represented by an interval and there is the need of representing both point-based and interval-based data dependencies. In this paper, we propose ITFDs based on Allen's interval relations and discuss their expressive power with respect to other TFDs proposed in the literature: ITFDs allow us to express interval-based data dependencies, which cannot be expressed through the existing point-based TFDs. ITFDs allow one to express constraints such as "employees starting to work the same day with the same role get the same salary" or "employees with a given role working on a project cannot start to work with the same role on another project that will end before the first one". Furthermore, we propose new algorithms based on B-trees to efficiently verify the satisfaction of ITFDs in a temporal database. These algorithms guarantee that, starting from a relation satisfying a set of ITFDs, the updated relation still satisfies the given ITFDs.

Performance of program modification techniques that ensure serializable executions with snapshot isolation DBMS

Snapshot Isolation (SI) is a multiversion concurrency control that has been implemented by several open source and commercial database systems (Oracle, Microsoft SQL Server, and previous releases of PostgreSQL). The main feature of SI is that a read operation does not block a write operation and vice versa, which allows higher degree of concurrency than traditional two-phase locking. SI prevents many anomalies that appear in other isolation levels, but it still can result in non-serializable executions, in which database integrity constraints can be violated. Several techniques are known to modify the application code based on preanalysis, in order to ensure that every execution is serializable on engines running SI. We introduce a new technique called External Lock Manager (ELM). In using a technique, there is a choice to make, of which pairs of transactions need to have conflicts introduced. We measure the performance impact of the choices available, among techniques and conflicts.

A Model-Theoretic Approach to Belief Change in Answer Set Programming

We address the problem of belief change in (nonmonotonic) logic programming under answer set semantics. Our formal techniques are analogous to those of distance-based belief revision in propositional logic. In particular, we build upon the model theory of logic programs furnished by SE interpretations, where an SE interpretation is a model of a logic program in the same way that a classical interpretation is a model of a propositional formula. Hence we extend techniques from the area of belief revision based on distance between models to belief change in logic programs. We first consider belief revision: for logic programs P and Q , the goal is to determine a program R that corresponds to the revision of P by Q , denoted P * Q . We investigate several operators, including (logic program) expansion and two revision operators based on the distance between the SE models of logic programs. It proves to be the case that expansion is an interesting operator in its own right, unlike in classical belief revision where it is relatively uninteresting. Expansion and revision are shown to satisfy a suite of interesting properties; in particular, our revision operators satisfy all or nearly all of the AGM postulates for revision. We next consider approaches for merging a set of logic programs, P 1 , ..., P n . Again, our formal techniques are based on notions of relative distance between the SE models of the logic programs. Two approaches are examined. The first informally selects for each program P i those models of P i that vary the least from models of the other programs. The second approach informally selects those models of a program P 0 that are closest to the models of programs P 1 , ..., P n . In this case, P 0 can be thought of as a set of database integrity constraints. We examine these operators with regards to how they satisfy relevant postulate sets. Last, we present encodings for computing the revision as well as the merging of logic programs within the same logic programming framework. This gives rise to a direct implementation of our approach in terms of off-the-shelf answer set solvers. These encodings also reflect the fact that our change operators do not increase the complexity of the base formalism.

An Automatic Test Database Generation Algorithm Based on RQP

Software testing is one of key technologies to guarantee quality and reliability of software. Most computer applications are related to database application systems. Test database generation is an important research topic of database application testing. There are a number of commercial tools to automatically generate test databases. These tools take the database schema and table sizes as input in order to generate new tuples. However, these tools often generate test databases which do not reflect the semantics of the application logic that should be tested. In this paper, we propose a test database generation algorithm based on RQP (Reverse Query Processing). Using database integrity constraints, our proposal first obtains data dependence of test data generation between separate tables in database, and then applies RQP to a top-down test database generation according to tester specified queries. The referential values in top tables are involved in test data generation of down tables when deriving tester specified queries. Algorithm analysis and case studies show that the test data generated from our new algorithm satisfies the database integrity constraints. The new algorithm improves the efficiency of the test database generation significantly, as well as follows the testing requirements of tester specified queries.

Formal classification of integrity constraints in spatiotemporal database applications

Imposing integrity constraints is an efficient way to improve data quality in databases. Effective imposition of integrity constraints requires their precise distinction and specification. Despite a few efforts for enhancing the distinction and specification of the integrity constraints in spatial and spatiotemporal databases by their classifications, these classifications fail to precisely distinguish between inherently dissimilar integrity constraints. Furthermore, the existing classifications provide imprecise definitions for the classes of integrity constraints. Such shortcomings explain why still diverse terms are used to refer to a same spatial integrity constraint. In this paper, we propose a formal and more exhaustive classification of the integrity constraints in spatiotemporal databases relying on their nature with respect to space, time, and themes. Moreover, a terminology for the integrity constraints of spatiotemporal databases is presented. Finally, we discuss the advantages of the proposed classification in the specification of integrity constraints.

Extending UML Profiles to Model Integrity Constraints in SQL Databases

Extending UML Profiles to Model Integrity Constraints in SQL Databases

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.

Conditional functional dependencies for capturing data inconsistencies

We propose a class of integrity constraints for relational databases, referred to as conditional functional dependencies (CFDs), and study their applications in data cleaning. In contrast to traditional functional dependencies (FDs) that were developed mainly for schema design, CFDs aim at capturing the consistency of data by enforcing bindings of semantically related values. For static analysis of CFDs we investigate the consistency problem , which is to determine whether or not there exists a nonempty database satisfying a given set of CFDs, and the implication problem , which is to decide whether or not a set of CFDs entails another CFD. We show that while any set of transitional FDs is trivially consistent, the consistency problem is NP-complete for CFDs, but it is in PTIME when either the database schema is predefined or no attributes involved in the CFDs have a finite domain. For the implication analysis of CFDs, we provide an inference system analogous to Armstrong's axioms for FDs, and show that the implication problem is coNP-complete for CFDs in contrast to the linear-time complexity for their traditional counterpart. We also present an algorithm for computing a minimal cover of a set of CFDs. Since CFDs allow data bindings, in some cases CFDs may be physically large, complicating the detection of constraint violations. We develop techniques for detecting CFD violations in SQL as well as novel techniques for checking multiple constraints by a single query. We also provide incremental methods for checking CFDs in response to changes to the database. We experimentally verify the effectiveness of our CFD-based methods for inconsistency detection. This work not only yields a constraint theory for CFDs but is also a step toward a practical constraint-based method for improving data quality.

Semantic Integrity Constraint Checking for Multiple XML Databases

Global semantic integrity constraints ensure integrity and consistency of data spanning multiple databases. In this paper, we take initial steps towards representing global semantic integrity constraints for XML databases. We also provide a general framework for checking global semantic integrity constraints for XML databases. Furthermore, we set forth an efficient algorithm for checking global semantic integrity constraints across multiple XML databases. Our algorithm is efficient for three reasons: (1) the algorithm does not require the update statement to be executed before the constraint check is carried out; hence, we avoid any potential problems associated with rollbacks, (2) sub constraint checks are executed in parallel, and (3) most of the processing of algorithm could happen at compile time; hence, we save time spent at run-time. As a proof of concept, we present a prototype of the system implementing the ideas discussed in this paper.

Measuring inconsistency in knowledgebases

It is well-known that knowledgebases may contain inconsistencies. We provide a measure to quantify the inconsistency of a knowledgebase, thereby allowing for the comparison of the inconsistency of various knowledgebases, represented as first-order logic formulas. We use quasi-classical (QC) logic for this purpose. QC logic is a formalism for reasoning and analysing inconsistent information. It has been used as the basis of a framework for measuring inconsistency in propositional theories. Here we extend this framework, by using a first-order logic version of QC logic for measuring inconsistency in first-order theories. We motivate the QC logic approach by considering some formulae as database or knowledgebase integrity constraints. We then define a measure of extrinsic inconsistency that can be used to compare the inconsistency of different knowledgebases. This measure takes into account both the language used and the underlying domain. We show why this definition also captures the intrinsic inconsistency of a knowledgebase. We also provide a formalization of paraconsistent equality, called quasi-equality, and we use this in an extended example of an application for measuring inconsistency between heterogeneous sources of information and integrity constraints prior to merging.