Sharma Chakravarthy

Snoop: an expressive event specification language for active databases

Making a database system active to meet the requirements of a wide range of applications entails developing an expressive event specification language and its implementation. Extant systems support mostly database events and in some cases a few predefined events. This paper discusses an event specification language (termed Snoop) for active databases. We define an event, distinguish between events and conditions, classify events into a class hierarchy, identify primitive events, and introduce a small number of event operators for constructing composite (or complex) events. Snoop supports temporal, explicit, and composite events in addition to the traditional database events. The novel aspect of our work lies not only in supporting a rich set of events and event expressions, but also in the notion of parameter contexts. Essentially, parameter contexts augment the semantics of composite events for computing their parameters. For concreteness, we present parameter computation for the relational model. Finally, we show how a contingency plan that includes time constraints can be supported without stepping outside of the framework proposed in this paper.

SnoopIB: interval-based event specification and detection for active databases

Detection-based semantics does not differentiate between event detection and event occurrence and has been used for detecting events in most of the active systems that support Event-Condition-Action rules. However, this is a limitation for many applications that require interval-based semantics. In this article, we formalize the detection of Snoop (an event specification language) event operators using interval-based semantics (termed SnoopIB) in various event consumption modes. We show how events are detected using event detection graphs, and present a few representative algorithms to detect SnoopIB operators and comment on their implementation in the context of Sentinel-an active object-oriented DBMS.

A new perspective on rule support for object-oriented databases

This paper proposes a new approach for supporting reactive capability in an object-oriented database. We introduce an event interface, which extends the conventional object semantics to include the role of an event generator. This interface provides a basis for the specification of events spanning sets of objects, possibly from different classes, and detection of primitive and complex events. This approach clearly separated event detection from rules. New rules can be added and use existing objects, enabling objects to react to their own changes as well as to the changes of other objects. We use a runtime subscription mechanism, between rules and objects to selectively monitor particular objects dynamically. This elegantly supports class level as well as instance level rules. Both events and rules are treated as first class objects.

Design of Sentinel: an object-oriented DMBS with event-based rules

Abstract This paper describes the design of event-condition-action (ECA) rules for supporting active capability in an object-oriented DBMS and sketches its incorporation in a C++ environment. We summarize Snoop—an expressive event specification language which supports temporal, explicit, and composite events in addition to the traditional database events. A small set of event operators is introduced for building composite events. We also introduce an event interface to extend the conventional object semantics to include the specification of primitive events. This interface is used as a basis for the specification of events spanning objects, possibly from different classes, and detection of primitive and composite events. New rules can be introduced on existing objects, enabling objects to react to their own changes as well as to the changes of other objects. We introduce a runtime subscription mechanism between rules and objects to monitor objects selectively. This mechanism elegantly supports class level as well as instance level rules. Finally, using an illustrative example, we compare the functionality of our approach with related work.

Rule management and evaluation: an active DBMS perspective

An active database management system is characterized by its ability to monitor and react to both database and nondatabase events in a timely and efficient manner. There have been several attempts at integrating this capability with conventional, passive DBMSs. In fact, this capability has been shown to be pivotal for supporting a variety of database functions in an elegant manner.

Scheduling Strategies for Processing Continuous Queries over Streams

Stream data processing poses many challenges. Two important characteristics of stream data processing – bursty arrival rates and the need for near real-time performance requirement – challenge the allocation of limited resources in the system. Several scheduling algorithms (e.g., Chain strategy) have been proposed for minimizing the maximal memory requirements in the literature. In this paper, we propose novel scheduling strategies to minimize tuple latency as well as total memory requirement. We first introduce a path capacity strategy (PCS) with the goal of minimizing tuple latency. We then compare the PCS and the Chain strategy to identify their limitations and propose additional scheduling strategies that improve upon them. Specifically, we introduce a segment strategy (SS) with the goal of minimizing the memory requirement, and its simplified version. In addition, we introduce a hybrid strategy, termed the threshold strategy (TS), to addresses the combined optimization of both tuple latency and memory requirement. Finally, we present the results of a wide range of experiments conducted to evaluate the efficiency and the effectiveness of the proposed scheduling strategies.

Real-time transaction scheduling: a cost conscious approach

Real-time databases are an important component of embedded real-time systems. In a real-time database context, transactions must not only maintain the consistency constraints of the database but must also satisfy the timing constraints specified for each transaction. Although several approaches have been proposed to integrate real-time scheduling and database concurrency control methods, none of them take into account the dynamic cost of scheduling a transaction. In this paper, we propose a new cost conscious real-time transaction scheduling algorithm which considers dynamic costs associated with a transaction. Our dynamic priority assignment algorithm adapts to changes in the system load without causing excessive numbers of transaction restarts. Our simulations show its superiority over EDF-HP algorithm.

An objective function for vertically partitioning relations in distributed databases and its analysis

Partitioning and allocation of relations is an important component of the distributed database design. Several approaches (and algorithms) have been proposed for clustering data for pattern classification and for partitioning relations in distributed databases. Most of the approaches used for classification use square-error criterion. In contrast, most of the approaches proposed for partitioning of relations are eitherad hoc solutions or solutions for special cases (e.g., binary vertical partitioning).In this paper, we first highlight the differences between the approaches taken for pattern classification and for distributed databases. Then an objective function for vertical partitioning of relations is derived using the square-error criterion commonly used in data clustering. The objective function derived generalizes and subsumes earlier work on vertical partitioning. Furthermore, the approach proposed in this paper is shown to be useful for comparing previously developed algorithms for vertical partitioning. The objective function has also been extended to include additional information, such as transaction types, different local and remote accessing costs and replication. Finally, we discuss the implementation of a distributed database design testbed.

ECA rule integration into an OODBMS: architecture and implementation

Making a database system active entails not only the specification of expressive ECA (event-condition-action) rules, algorithms for the detection of composite events, and rule management, but also a viable architecture for rule execution that extends a passive DBMS, and its implementation. We propose an integrated active DBMS architecture for incorporating ECA rules using the Open OODB Toolkit (from Texas Instruments). We then describe the implementation of the composite event detector, and rule execution model for object-oriented active DBMS. Finally, the functionality supported by this architecture and its extensibility are analyzed along with the experiences gained.<<ETX>>

Sentinel: an object-oriented DBMS with event-based rules

Active or reactive database management systems (DBMSS) provide an event-based rule capability that can be used to support a number of database functionality (e.g., integrity enforcement, view materialization, management of index structures, applicability of compiled query plane when access methods change) in a uniform way. Rules used for supporting active capability consists ofi au event expression, one or more conditions, an action, and a set of attributes. occurrence triggers the evaluation of the condlt ion. A condition is a aide effect-free boolean computation (set computation in general) on the database state and an action is an arbitrary sequence of operations. Attributes, typically, specify rule characteristics such as coupling mode, event consumption mode, and precedence relationahlp among rules. A rule with these. components is termed an ECA or event-condition-action rule in the literature [3]. 2 Paradigm Differences C1early,there is a paradigm shift when we move horn the relational model to an object-oriented one. The dflerences between the two data models profoundly influence how the concepts and techniques are carried over from one model to the other. Below, we enumerate some of the differences between the data models that led to the design choices made for Sentinel 1. In contrast to a fixed number of pm-defied primitive system events in the relational model (e.g., update, insert, delete), every method/mesaage is a potential event in an 00DBMS. These methods are defined in application classes, making detection potentially more dimcult. 2. The principle of encapsulation and further the distinctions between features supported (e.g., private, pro-Permission to make digital/hard copy of part or ell this work for personal or claasroom use is granted without fee provided that copies are not made or distributed for profit or commercial sdvan-tage, the copyright notice, the title of the publication and its date appear, snd notice ia given that copying is by permission of ACM, tected, and public in C++, class and instance attributes in Common Lisp with Flavora) need to be accounted for; this is orthogonal to both the access control issue and global nature of rules in the relational database context, The principle of inheritance and its effect on rule incorporation , and Scope, accessibility, and visibility of object states for rules. The above differences imply that some of the techniques used in the relational context may not be appropriate for the 00 pamdgm. For example, large number of methods (both user and system defined) entail that …