253 research outputs found
Integrity Control in Relational Database Systems - An Overview
This paper gives an overview of research regarding integrity control or integrity constraint handling in relational database management systems. The topic of constraint handling is discussed from two points of view. First, constraint handling is discussed by identifying a number of important research issues, and by treating each issue in detail. Second, a number of projects is described that have resulted in the realization of database management systems supporting integrity constraints; the various projects are compared with respect to a number of system characteristics. Together, both approaches give a broad overview of the state of the art in the field at this moment
Using UML’s Sequence Diagrams for Representing Execution Models Associated to Triggers
11 pages, 3 figures.-- Contributed to: 23rd British National Conference on Databases (BNCOD 23, Belfast, Northern Ireland, UK, July 18-20, 2006).Using active rules or triggers to verify integrity constraints is a serious and complex problem because these mechanisms have behaviour that could be difficult to predict in a complex database. The situation is even worse as there are few tools available for developing and verifying them. We believe that automatic support for trigger development and verification would help database developers to adopt triggers in the database design process. Therefore, in this work we suggest a visualization add-in tool that represents and verifies triggers execution by using UML’s sequence diagrams. This tool is added in RATIONAL ROSE and it simulates the execution sequence of a set of triggers when a DML operation is produced. This tool uses the SQL standard to express the triggers semantics and execution.This work is part of the project "Software Process Management Platform: modelling, reuse and measurement". TIN2004/07083.Publicad
Concurrent rule execution in active databases
Cataloged from PDF version of article.An active DBMS is expected to support concurrent as well as sequential rule execution
in an efficient manner. Nested transaction model is a suitable tool to implement rule execution as it can
handle nested rule firing and concurrent rule execution well. In this paper, we describe a concurrent
rule execution model based on parallel nested transactions. We discuss implementation details of how
the flat transaction model of OpenOODB has been extended by using Solaris threads in order to
SUppOrt COnCUrrent eXeCUtiOU of rUkS.
Database rules and time: some proposed extensions to the SQL standard
The subject of this thesis is the incorporation of temporal
semantics into database rules and how the resultant syntax
might be reconciled with the evolving SQL standard. In particular, it explores time-driven rules and the time-relationship between triggering events and associated actions.
A review of the key research results in the area of
database rules and the syntax developed for the major
prototype implementations is conducted, and a working
syntax , free of any limitations within the SQL standard,
developed. Next, an operational definition is evolved
through the application of this working syntax to two
sample domains rich in 'temporal rules'. In each case a
graphical representation of the domain is presented using
an adapted object-oriented modelling technique followed by
a mapping into the working temporal syntax.
Attention is then turned to the SQL-92 standard and its
future successor SQL3. An assessment is made of their
implications for the working syntax developed in the
earlier chapters - with particular reference to the
specification of time and the use of database triggers.
When an attempt was made to re-cast the working syntax into
SQL, a satisfactory mapping, which succeeded in preserving
the semantics of the original, could not be achieved.
Support for time-based triggers; cyclic operations;
delayed actions and rule lifetimes necessitated the
development of appropriate modifications to the basic SQL3
draft syntax. The proposed extensions capture all of the
semantics required for the specification of time-based
rules.
The example applications indicated that an extended SQLcompliant
language approach allied to a sound objectoriented
modelling formalism had a broad applicability.
Furthermore, it was apparent that the addition of a
temporal dimension to rule actions was a key enabling
factor in increasing their semantic power
Management of object-oriented action-based distributed programs
Phd ThesisThis thesis addresses the problem of managing the runtime behaviour of distributed
programs. The thesis of this work is that management is fundamentally
an information processing activity and that the object model, as applied to actionbased
distributed systems and database systems, is an appropriate representation
of the management information. In this approach, the basic concepts of classes,
objects, relationships, and atomic transition systems are used to form object
models of distributed programs. Distributed programs are collections of objects
whose methods are structured using atomic actions, i.e., atomic transactions.
Object models are formed of two submodels, each representing a fundamental
aspect of a distributed program. The structural submodel represents a static
perspective of the distributed program, and the control submodel represents a
dynamic perspective of it. Structural models represent the program's objects,
classes and their relationships. Control models represent the program's object
states, events, guards and actions-a transition system. Resolution of queries on
the distributed program's object model enable the management system to control
certain activities of distributed programs.
At a different level of abstraction, the distributed program can be seen as a
reactive system where two subprograms interact: an application program and a
management program; they interact only through sensors and actuators. Sensors
are methods used to probe an object's state and actuators are methods used
to change an object's state. The management program is capable to prod the
application program into action by activating sensors and actuators available at
the interface of the application program. Actions are determined by management
policies that are encoded in the management program. This way of structuring
the management system encourages a clear modularization of application and
management distributed programs, allowing better separation of concerns. Managemental
concerns can be dealt with by the management program, functional
concerns can be assigned to the application program.
The object-oriented action-based computational model adopted by the management
system provides a natural framework for the implementation of faulttolerant
distributed programs. Object orientation provides modularity and extensibility
through object encapsulation. Atomic actions guarantee the consistency of
the objects of the distributed program despite concurrency and failures. Replication
of the distributed program provides increased fault-tolerance by guaranteeing
the consistent progress of the computation, even though some of the replicated
objects can fail.
A prototype management system based on the management theory proposed
above has been implemented atop Arjuna; an object-oriented programming system
which provides a set of tools for constructing fault-tolerant distributed programs. The management system is composed of two subsystems: Stabilis, a
management system for structural information, and Vigil, a management system
for control information. Example applications have been implemented to illustrate
the use of the management system and gather experimental evidence to give
support to the thesis.CNPq (Consellho Nacional de Desenvolvimento Cientifico e Tecnol6gico, Brazil):
BROADCAST (Basic Research On Advanced Distributed Computing: from Algorithms to SysTems)
A Logical Approach to Cooperative Information Systems
``Cooperative information system management'' refers to the capacity of several computing systems to communicate and cooperate in order to acquire, store, manage, query data and knowledge. Current solutions to the problem of cooperative information management are still far from being satisfactory. In particular, they lack the ability to fully model cooperation among heterogeneous systems according to a declarative style. The use of a logical approach to model all aspects of cooperation seems very promising. In this paper, we de®ne a logical language able to support cooperative queries, updates and update propagation. We model the sources of information as deductive databases, sharing the same logical language to ex- press queries and updates, but containing independent, even if possibly related, data. We use the Obj-U-Datalog (E. Bertino, G. Guerrini, D. Montesi, Toward deductive object data- bases, Theory and Practice of Object Systems 1 (1) (1995) 19±39) language to model queries and transactions in each source of data. Such language is then extended to deal with active rules in the style of Active-U-Datalog (E. Bertino, B. Catania, V. Gervasi, A. Ra aet a, Ac- tive-U-Datalog: Integrating active rules in a logical update language, in: B. Freitag, H. Decker, M. Kifer, A. Voronkov (Eds.), LBCS 1472: Transactions and Change in Login Databases, 1998, pp. 106±132), interpreted according to the PARK semantics proposed in G. Gottlob, G. Moerkotte, V.S. Subrahmanian (The PARK semantics for active rules, in: P.M.G. Apers, M. Bouzeghoub, G. Gardarin (Eds.), LNCS 1057: Proceedings of the Fifth International Con- ference on Extending Database Technology, 1996, pp. 35±55). By using active rules, a system can e ciently perform update propagation among di erent databases. The result is a logical environment, integrating active and deductive rules, to perform update propagation in a cooperative framework
A NEW APPROACH FOR CONFLICT RESOLUTION AND RULE PROCESSING IN A KNOWLEDGE-BASED SYSTEM
In a knowledge-based system, rules can be defined to derive virtual attributes. Conflicts occur if multiple rules are applicable and one must be selected based on some criterion, such as priority. We identify important properties of a conflict resolution method and describe a technique for resolving conflicts and efficiently processing queries involving virtual attributes in a knowledge-based system. It is shown that by transforming a given, prioritized set of rules into a conflict-free, priority independent form it is possible to do query processing in a set-at-a-time manner. Algorithms for conflict resolution and query processing are given
Structural Testing of Active DataBases
Active databases (ADBs) are databases that include active components or agents that can execute actions. The rise of active databases in the picture of software development has a great impact on software systems and in the discipline of software engineering. However, we still lack the foundations that are needed to adequately support this new tool. These foundations are needed in order to properly apply known software engineering techniques to ADBs and systems that use them. Among the methods and techniques used to improve quality, we count systematic testing. In this work, we generalize structural testing techniques to ADB systems. We introduce a model of active databases, called dbgraph, suitable for testing. We show that dbgraphs can be used to generalize structural testing techniques for ADBs. Moreover, we introduce several new structural criteria aimed at find errors in a set of rules for an ADB. We also compare the strength of the coverage criteria presented in this work.Supported in part by UBACyT grant EX186.Sociedad Argentina de Informática e Investigación Operativ
- …