, Exception, Clock, Externalg Granularity ae fMember, Subset, Setg Type ae fPrimitive, Composite g Operators ae for, and, seq, closure, times, not g Consumption mode ae fRecent, Chronicle, Cumulative, Continuous g Role 2 fMandatory, Optional, Noneg Condition Role 2 fMandatory, Optional, Noneg Context ae fDB T , BindE , DBE , DBC g Action Options ae fStructure Operation, Behavior Invocation, Update-Rules, Abort Inform, External, Do Instead g Context ae fDB T , BindE , BindC , DBE , DBC , DBA g ---behavior invocation, in which case the event is raised by the execution of some user-defined operation (e.g. the message display is sent to an object of type widget). It is common for event languages to allow events to be raised before or after an operation has been executed. ---transaction, in which case the event is raised by transaction commands (e.g. abort, commit, begin-transaction) ---abstract or user-defined, in which case a programming mechanism is used that allows an appli...

This paper describes our development of the Starburst Rule System, an active database rules facility integrated into the Starburst extensible relational database system at the IBM Almaden Research Center. The Starburst rule language is based on arbitrary database state transitions rather than tuple- or statement-level changes, yielding a clear and flexible execution semantics. The rule system has been implemented completely. Its rapid implementation was facilitated by the extensibility features of Starburst, and rule management and rule processing is integrated into all aspects of database processing. Index terms: active database systems, database production rules, extensible database systems, expert database systems 1 Introduction Active database systems allow users to create rules---rules specify data manipulation operations to be executed automatically whenever certain events occur or conditions are met. Active database rules provide a general and powerful mechanism for traditiona...

In this paper we take a first step towards characterizing active databases. Declarative characterization of active databases allows additional flexibility in studying the effects of different priority criteria between fireable rules, different actions and event definitions, and also to make claims about effects of transaction and prove them without actually executing them. Our characterization is related but different from similar attempts by Zaniolo in terms of making a clear distinction between actual and hypothetical execution of actions and allowing nondeterminism. We use the `choice' construct [SZ90] to characterize the non-determinism that arises when several rules can fire at the same time and the preference between them is not specified. We show through examples how our language allows us to express features of different active database systems.

An active database is a database in which some operations are automatically executed when specified events happen and particular conditions are met. Several systems supporting active rules in an object-oriented data model have been proposed. However, several issues related to the integration of triggers with object-oriented modeling concepts have not been satisfactorily addressed. In this paper, we discuss issues related to trigger inheritance and refinement in the context of the Chimera active object-oriented data model. In particular, we introduce a semantics for an active object language that takes into account trigger inheritance and supports trigger overriding. Moreover, we state conditions on trigger overriding ensuring that trigger semantics is preserved in subclasses.

Abstract. In this paper, we propose an efficient technique to statically manage integrity constraints in object-oriented database programming languages. We place ourselves in the context of a simplified database programming language, close to O2, in which we assume that updates are undertaken by means of methods. An important issue when dealing with constraints is that of efficiency. A nave management of such constraints can cause a severe floundering of the overall system. Our basic assumption is that the run-time checking of constraints is too costly to be undertaken systematically. Therefore, methods that are always safe with respect to integrity constraints should be proven so at compile time. The run-time checks should only concern the remaining methods. To that purpose, we propose a new approach, based on the use of predicate transformers combined with automatic theorem proving techniques, to prove the invariance of integrity constraints under complex methods. We then describe the current implementation of our prototype, and report some experiments that have been performed with it on non trivial examples. The counterpart of the problem of program verification is that of program correction. Static analysis techniques can also be applied to solve that problem. We present a systematic approach to undertake the automatic correction of potentially unsafe methods. However, the advantages of the latter technique are not as clear as those of program verification. We will therefore discuss some arguments for and against the use of method correction. 1

. While agents have emphasised the notion of active software components, they are not likely to be the only active components in agent-based systems. In this paper, we first discuss the general notion of active system, and show how it relates with the issue of the consistent observation of distributed and heterogeneous multi-component systems. Then, we introduce the concept of boundary interface as a methodological abstraction for the engineering of a society's environment composed by active systems, allowing observer agents to be provided with three different kinds of consistent environment views, featuring observable, controlled, and constrained consistency, respectively. 1

This work addresses the problem of maintaining the consistency of the answers to continuous queries which are posed by the users of the Moving Objects Databases (MOD). Assuming that the motion of the object is represented by a trajectory, we focus on the effect that the modifications to the trajectory data can have on the queries answer-set. In case a mobile user enters a road section in which an accident has occurred, which was not anticipated in the “expected ” traffic behavior, not only his trajectory needs to updated, but the answer to the query that he posed may need to be recalculated and transmitted again. In this work we propose a framework which enables detecting and processing the pending queries whose answers need to be re-evaluated upon modifications to the MOD. We identify the relevant syntactic elements which can be extracted from the user’s queries and we analyze their semantic implications. We also propose an architecture of a system that can be used for this task. We demonstrate how triggers can be used to maintain the answers to the users ’ queries “up to date ” with respect to the modifications to the MOD and we show that our framework can be implemented on top of the existing ORDBMS. I.

Triggers have been adopted as an important database feature and implemented by most major database vendors. Despite their diverse potential usages, one of the obstacles that hinder the triggers from its wide deployment is the lack of tools that aid users to create complex trigger rules in a simple manner. Although the majority of the users of triggers are DBAs or savvy end-users, writing trigger rules is still a daunting task. On the other hand, QBE (Query-By-Example) has been very popular as a user interface forcreating queries in an interactive and intuitive manner since its introduction decades ago. It is being used in most modern database products in its disguised form. Since its underlying theory is based on the relational calculus, its expressive power is proved to be equivalent to that of SQL. Therefore, it is an ideal tool for novice users to create simple queries in visual fashion. At the same time, expert users do not have to compromise anything because QBE supports full capability to create complex queries. In this paper, we shall present a novel user interface for creating trigger rules, called TBE (Trigger-By-Example), by marrying the triggers and QBE in a seamless fashion. The visual nature ofthe TBE makes writing trigger rules much easier. We show how trigger rules in the emerging SQL standard

This article presents an approach to build flexible active rule execution models. It introduces a framework that covers all phenomena associated with the behavior of active database systems. This framework is made up of a taxonomy that allows us to characterize execution models of existing active database systems and that has been used to provide the Flexible Active Rule Execution (Fl'ARE) model that is formally defined and implemented. The model is based on a set of constants and independent parameters that may take values within a set of predefined values. Those parameters and values have been identified from the dimensions of our taxonomy. These dimensions have been structured into two main classes: the dimensions of one rule execution and the dimensions on a module(set) of rules. Dimensions of one rule have been classified into intrinsic dimensions, dimensions related to the underlaying transaction model and dimensions related to the rule model. Having a flexible active rule execution model provides a support intended to design and develop new rule execution engines well-adapted to different uses of rules, to predict and understand the resulting behavior of active applications. Furthermore, the model is modular as it allows the integration of heterogeneous rule modules within the same application, each of them having its own semantics based on the service it is intended to support. Categories and Subject Descriptors: H.2.m [Information Systems]: Database management General Terms: Design, Theory, Experimentation Additional Key Words and Phrases: active databases, active rule systems, behavior, execution models A Parametric Active Rule Execution Model \Delta 1 1. INTRODUCTION 1.1 Context

In this paper, we propose an efficient technique to statically manage integrity constraints in objectoriented database programming languages. We place ourselves in the context of a simplified database programming language, close to O 2 , in which we assume that updates are undertaken by means of methods. An important issue when dealing with constraints is that of efficiency. A nave management of such constraints can cause a severe floundering of the overall system. Our basic assumption is that the runtime checking of constraints is too costly to be undertaken systematically. Therefore, methods that are always safe with respect to integrity constraints should be proven so at compile time. The run-time checks should only concern the remaining methods. To that purpose, we propose a new approach, based on the use of predicate transformers combined with automatic theorem proving techniques, to prove the invariance of integrity constraints under complex methods. We then describe th...