Integrity Checking and Maintenance in Relational and Deductive Database and Beyond

2011 ◽  
pp. 238-285 ◽  
Author(s):  
Davide Martinenghi ◽  
Henning Christiansen ◽  
Hendrik Decker
Keyword(s):  
Distributed Databases ◽  
Integrity Constraints ◽  
Deductive Database ◽  
Strong Impact ◽  
Document Collections ◽  
Active Rules ◽  
Integrity Checking ◽  
Xml Document ◽  
Semantic Correctness ◽  
The Given

Integrity constraints are a key tool for characterizing the well-formedness and semantics of the information contained in databases. In this regard, it is essential that intelligent database management systems provide their users with automatic support to effectively and efficiently maintain the semantic correctness of data with respect to the given integrity constraints. This chapter gives an overview of the field of efficient integrity checking and maintenance for relational as well as deductive databases. It covers both theoretical and practical aspects of integrity control, including integrity maintenance via active rules. New lines of research are outlined, particularly with regard to two topics where a strong impact for future developments can be expected: integrity in XML document collections and in distributed databases. Both pose a number of new and highly relevant research challenges to the database community.

Database Integrity Checking

2009 ◽  
pp. 212-220 ◽  
Author(s):  
Hendrik Decker ◽  
Davide Martinenghi
Keyword(s):  
Predicate Logic ◽  
Historical Background ◽  
Integrity Constraints ◽  
Future Trends ◽  
Declarative Languages ◽  
Incremental Evaluation ◽  
Database Integrity ◽  
Integrity Checking ◽  
Semantic Correctness ◽  
Formal Representations

Integrity constraints (or simply “constraints”) are formal representations of invariant conditions for the semantic correctness of database records. Constraints can be expressed in declarative languages such as datalog, predicate logic, or SQL. This article highlights the historical background of integrity constraints and the essential features of their simplified incremental evaluation. It concludes with an outlook on future trends.

Principles of Advanced Database Integrity Checking

2005 ◽  
pp. 2297-2302
Author(s):  
Hendrik Decker
Keyword(s):  
Knowledge Representation ◽  
Predicate Logic ◽  
Declarative Knowledge ◽  
Integrity Constraints ◽  
Database Integrity ◽  
Integrity Checking ◽  
Semantic Correctness ◽  
Formal Representations

Integrity constraints (hereafter, sometimes simply ‘constraints’) are formal representations of conditions for the semantic correctness of database records. In science, constraints are usually expressed in declarative knowledge representation languages such as datalog or predicate logic. In commercial databases, they are usually expressed by distinguished SQL statements.

Database Integrity Checking

2011 ◽  
pp. 961-966
Author(s):  
Hendrik Decker ◽  
Davide Martinenghi
Keyword(s):  
Predicate Logic ◽  
Historical Background ◽  
Integrity Constraints ◽  
Future Trends ◽  
Declarative Languages ◽  
Incremental Evaluation ◽  
Database Integrity ◽  
Integrity Checking ◽  
Semantic Correctness ◽  
Formal Representations

Integrity constraints (or simply “constraints”) are formal representations of invariant conditions for the semantic correctness of database records. Constraints can be expressed in declarative languages such as datalog, predicate logic, or SQL. This article highlights the historical background of integrity constraints and the essential features of their simplified incremental evaluation. It concludes with an outlook on future trends.

Improving Constraints Checking in Distributed Databases with Complete, Sufficient, and Support Tests

2009 ◽  
pp. 335-347
Author(s):  
Ali Amer Alwan ◽  
Hamidah Ibrahim ◽  
Nur Izura Udzir
Keyword(s):  
Distributed Databases ◽  
Integrity Constraints ◽  
Initial State ◽  
Enforcement Mechanism ◽  
Integrity Checking ◽  
Integrity Tests

A database state is said to be consistent if and only if it satisfies the set of integrity constraints. A database state may change into a new state when it is updated either by a single update operation (insert, delete, or modify) or by a sequence of updates (transaction). If a constraint is false in the new state, the new state is inconsistent, therefore the enforcement mechanism can either perform compensatory actions to produce a new consistent state, or restore the initial state by undoing the update operation. The steps generate integrity tests that are queries composed from the integrity constraints and the update operations, and run these queries against the database, which check whether all the integrity constraints of the database are satisfied; are referred to as integrity checking (Alwan, Ibrahim, & Udzir, 2007; Ibrahim, 2006; Ibrahim, Gray & Fiddian, 2001), is the main focus of this chapter.

scholarly journals BTK, NUTM2A, and PRPF19 Are Novel KMT2A Partner Genes in Childhood Acute Leukemia

Biomedicines ◽  
2021 ◽  
Vol 9 (8) ◽  
pp. 924
Author(s):  
Elena Zerkalenkova ◽  
Svetlana Lebedeva ◽  
Aleksandra Borkovskaia ◽  
Olga Soldatkina ◽  
Olga Plekhanova ◽  
...  
Keyword(s):  
Acute Leukemia ◽  
Residual Disease ◽  
Chromosomal Rearrangements ◽  
Strong Impact ◽  
Acute Leukemias ◽  
Dna And Rna ◽  
Targeted Ngs ◽  
Childhood Acute Leukemia ◽  
Next Generation Sequencing Ngs ◽  
The Given

Chromosomal rearrangements of the human KMT2A/MLL gene are associated with acute leukemias, especially in infants. KMT2A is rearranged with a big variety of partner genes and in multiple breakpoint locations. Detection of all types of KMT2A rearrangements is an essential part of acute leukemia initial diagnostics and follow-up, as it has a strong impact on the patients’ outcome. Due to their high heterogeneity, KMT2A rearrangements are most effectively uncovered by next-generation sequencing (NGS), which, however, requires a thorough prescreening by cytogenetics. Here, we aimed to characterize uncommon KMT2A rearrangements in childhood acute leukemia by conventional karyotyping, FISH, and targeted NGS on both DNA and RNA level with subsequent validation. As a result of this comprehensive approach, three novel KMT2A rearrangements were discovered: ins(X;11)(q26;q13q25)/KMT2A-BTK, t(10;11)(q22;q23.3)/KMT2A-NUTM2A, and inv(11)(q12.2q23.3)/KMT2A-PRPF19. These novel KMT2A-chimeric genes expand our knowledge of the mechanisms of KMT2A-associated leukemogenesis and allow tracing the dynamics of minimal residual disease in the given patients.

scholarly journals Validation of schema mappings with nested queries

2013 ◽  
Vol 10 (1) ◽  
pp. 79-104
Author(s):  
Guillem Rull ◽  
Carles Farré ◽  
Ernest Teniente ◽  
Toni Urpí
Keyword(s):  
Integrity Constraints ◽  
Automatic Process ◽  
Document Type ◽  
Relational Schemas ◽  
Schema Mappings ◽  
Nested Data ◽  
Nested Queries ◽  
The Given ◽  
Human Designer ◽  
The Web

With the emergence of the Web and the wide use of XML for representing data, the ability to map not only flat relational but also nested data has become crucial. The design of schema mappings is a semi-automatic process. A human designer is needed to guide the process, choose among mapping candidates, and successively refine the mapping. The designer needs a way to figure out whether the mapping is what was intended. Our approach to mapping validation allows the designer to check whether the mapping satisfies certain desirable properties. In this paper, we focus on the validation of mappings between nested relational schemas, in which the mapping assertions are either inclusions or equalities of nested queries. We focus on the nested relational setting since most XML?s Document Type Definitions (DTDs) can be represented in this model. We perform the validation by reasoning on the schemas and mapping definition. We take into account the integrity constraints defined on both the source and target schema. We consider constraints and mapping?s queries which may contain arithmetic comparisons and negations. This class of mapping scenarios is significantly more expressive than the ones addressed by previous work on nested relational mapping validation. We encode the given mapping scenario into a single flat database schema, so we can take advantage of our previous work on validating flat relational mappings, and reformulate each desirable property check as a query satisfiability problem.

Translating Advanced Integrity Checking Technology to SQL

2002 ◽  
pp. 203-249 ◽  
Author(s):  
Hendrik Decker
Keyword(s):  
Natural Language ◽  
Order Logic ◽  
Predicate Calculus ◽  
Integrity Constraints ◽  
First Order Logic ◽  
First Order ◽  
Integrity Checking ◽  
Natural Language Interface ◽  
User Friendly ◽  
Declarative Specifications

The main goal of this chapter is to arrive at a coherent technology for deriving efficient SQL triggers from declarative specifications of arbitrary integrity constraints. The user may specify integrity constraints declaratively as closed queries in predicate calculus syntax (i.e., sentences in the language of first-order logic, abbr. FOL), as datalog denials, as query conditions in SQL WHERE clauses, or in some other, possibly more user-friendly manner (e.g., via a dialog-driven graphical or natural language interface which internally translates to equivalent WHERE clause conditions). As we are going to see, the triggers derived from such specifications behave such that whenever some update event would violate any of the integrity constraints, one or several of the triggers derived from that constraint are activated in order to enforce the constraint. That is, the violation is either prevented by rolling back the update or repaired instantly by subsequent further updates.

Sign in / Sign up

Export Citation Format

Share Document