85,672 research outputs found
A theorem prover-based analysis tool for object-oriented databases
We present a theorem-prover based analysis tool for object-oriented database systems with integrity constraints. Object-oriented database specifications are mapped to higher-order logic (HOL). This allows us to reason about the semantics of database operations using a mechanical theorem prover such as Isabelle or PVS. The tool can be used to verify various semantics requirements of the schema (such as transaction safety, compensation, and commutativity) to support the advanced transaction models used in workflow and cooperative work. We give an example of method safety analysis for the generic structure editing operations of a cooperative authoring system
Path constraints in semistructured databases
AbstractWe investigate a class of path constraints that is of interest in connection with both semistructured and structured data. In standard database systems, constraints are typically expressed as part of the schema, but in semistructured data there is no explicit schema and path constraints provide a natural alternative. As with structured data, path constraints on semistructured data express integrity constraints associated with the semantics of data and are important in query optimization. We show that in semistructured databases, despite the simple syntax of the constraints, their associated implication problem is r.e. complete and finite implication problem is co-r.e. complete. However, we establish the decidability of the implication and finite implication problems for several fragments of the path constraint language and demonstrate that these fragments suffice to express important semantic information such as extent constraints, inverse relationships, and local database constraints commonly found in object-oriented databases
Development of an Assertion Model of Integrity Constraints in Object-Oriented Databases
Object-Oriented Databases (OODBs) have been designed to support
large and complex programming projects. The data accuracy,
consistency, and integrity in OODBs are extremely important for
developers and users. Checking the integrity constraints in OODBs is
a fundamental problem in database design. Existing OODB
Management Systems (OODBMSs) lack to a capability of an ad-hoc
declarative specification of enforcing and maintaining integrity
constraints that are appeared among attributes in association,
composition, and inheritance hierarchies' relationships.
A critical problem in the existing OODBs is that they cannot support
User-Defmed Constraints (UDCs) that can be defmed in classes with
composition (logical or physical composition) and inherence (single or
mUltiple inheritance) hierarchies. Integrity constraints in the current OODBMSs are maintained either by disallowing and rolling back
transaction or modifying operations that may produce a violation.
The constraints must be maintained in the backward direction along
the class composition hierarchy as well as in the forward direction.
In this work an Assertion Model of Integrity Constraints (AMIC) is
proposed. The AMIC keeps the derivation path along with the
attributes' relationships that are derived from association,
composition, and inheritance hierarchies. The AMIC techniques are
designed to implement the needed functions that are collecting the
attributes' relationships and checking the integrity constraints.
Moreover, AMIC keeps UDCs with their relationships in both single
classes and multilevel classes (intra-class and inter-class).
Furthermore, the AMIC can maintain constraints in a single object
and a set of distributed objects (intra-object and inter-object).
Therefore, this makes the new model extendable and can be
integrated with any existing constraints' service.
A new technique called Detection Method (DM) isdesigned to check
the Object Meta Data (OMD) to detect the constraints violation before
it occurs. The AMIC is designed for both Centralized Integrity
Maintenance (CIM) and Application-Oriented Integrity Maintenance
(AOIM). The AMIC can also enforce and maintain structural and
logical integrity constraints, in addition to enforce and maintain
redundant, inconsistent, and duplicate constraints
Mapping between Alloy specifications and database implementations
The emergence of lightweight formal methods tools such as Alloy improves the software design process, by encouraging developers to model and verify their systems before engaging in hideous implementation details. However, an abstract Alloy specification is far from an actual implementation, and manually refining the former into the latter is unfortunately a non-trivial task. This paper identifies a subset of the Alloy language that is equivalent to a relational database schema with the most conventional integrity constraints, namely functional and inclusion dependencies. This semantic correspondence enables both the automatic translation of Alloy specifications into relational database schemas and the reengineering of legacy databases into Alloy. The paper also discusses how to derive an object-oriented application layer to serve as interface to the underlying database
Towards Intelligent Databases
This article is a presentation of the objectives and techniques
of deductive databases. The deductive approach to databases aims at extending
with intensional definitions other database paradigms that describe
applications extensionaUy. We first show how constructive specifications can
be expressed with deduction rules, and how normative conditions can be defined
using integrity constraints. We outline the principles of bottom-up and
top-down query answering procedures and present the techniques used for
integrity checking. We then argue that it is often desirable to manage with
a database system not only database applications, but also specifications of
system components. We present such meta-level specifications and discuss
their advantages over conventional approaches
Compensation methods to support generic graph editing: A case study in automated verification of schema requirements for an advanced transaction model
Compensation plays an important role in advanced transaction models, cooperative work, and workflow systems. However, compensation operations are often simply written as a^−1 in
transaction model literature. This notation ignores any operation parameters, results, and side effects. A schema designer intending to use an advanced transaction model is expected (required) to write correct method code. However, in the days of cut-and-paste, this is much easier said than done. In this paper, we demonstrate the feasibility of using an off-the-shelf theorem prover (also called a proof assistant) to perform automated verification of compensation requirements for an OODB schema. We report on the results of a case study in verification for a particular advanced transaction model that supports cooperative applications. The case study is based on an OODB schema that provides generic graph editing functionality for the creation, insertion, and manipulation of nodes and links
Automatic Verification of Transactions on an Object-Oriented Database
In the context of the object-oriented data model, a compiletime approach is given that provides for a significant reduction of the amount of run-time transaction overhead due to integrity constraint checking. The higher-order logic Isabelle theorem prover is used to automatically prove which constraints might, or might not be violated by a given transaction in a manner analogous to the one used by Sheard and Stemple (1989) for the relational data model. A prototype transaction verification tool has been implemented, which automates the semantic mappings and generates proof goals for Isabelle. Test results are discussed to illustrate the effectiveness of our approach
Steps Towards a Method for the Formal Modeling of Dynamic Objects
Fragments of a method to formally specify object-oriented models of a universe of discourse are presented. The task of finding such models is divided into three subtasks, object classification, event specification, and the specification of the life cycle of an object. Each of these subtasks is further subdivided, and for each of the subtasks heuristics are given that can aid the analyst in deciding how to represent a particular aspect of the real world. The main sources of inspiration are Jackson System Development, algebraic specification of data- and object types, and algebraic specification of processes
- …