Complex Event Processing

The emergence of event-driven architectures, automation of business processes, drastic cost-reductions in sensor technology, and a growing need to monitor IT systems (as well as other systems) due to legal, contractual, or operational considerations lead to an increasing generation of events . This development is accompanied by a growing demand for managing and processing events in an automated and systematic way. Complex Event Processing (CEP) encompasses the (automatable) tasks involved in making sense of all events in a system by deriving higher-level knowledge from lower-level events while the events occur, i.e., in a timely, online fashion and permanently.

Event Queries

At the core of CEP are queries which monitor streams of "simple" events for so-called complex events, that is, events or situations that manifest themselves in certain combinations of several events occurring (or not occurring) over time and that cannot be detected from looking only at single events. Querying events is fundamentally different from traditional querying and reasoning with database or Web data, since event queries are standing queries that are evaluated over time against incoming streams of event data. In order to express complex events that are of interest to a particular application or user in a convenient, concise, cost-effective and maintainable manner, special purpose Event Query Languages (EQLs) are needed.

High-Level Language

This project investigates practical and theoretical issues related to querying complex events, covering the spectrum from language design over declarative semantics to operational semantics for incremental query evaluation. Its central topic is the development of the high-level event query language XChange^EQ.

XChange^EQ's language design recognizes the four querying dimensions of data extractions, event composition, temporal relationships, and, for non-monotonic queries involving negation or aggregation, event accumulation. XChange^EQ deals with complex structured data in event messages, thus addressing the need to query events communicated in XML formats over the Web. It supports deductive rules as an abstraction and reasoning mechanism for events. To achieve a full coverage of the four querying dimensions, it builds upon a separation of concerns of the four querying dimensions, which makes it easy-to-use and highly expressive. XChange^EQ builds upon Xcerpt for querying events communicated as XML messages and can be embedded as event query language into the reactive language XChange.

Typing and schema languages based on tree grammars are widely accepted in the XML and Web community. In particular DTD, XML Schema and Relax NG are based on regular tree grammars. The purpose of such formalisms inspired by tree grammars range from documentation, data validation to type checking of query and transformation languages such as XQuery and XSLT.

Although graph structured XML data - built using reference mechanisms such as ID/IDREF - is widespread, common schema languages have no notion of typed references. In other words, formalisms based on tree grammars do not fully convey the graph structures of XML and semistructured data. Graph grammars aim at filling this gap. Regular (rooted) graph grammars are proposed as an extension of regular tree grammars, providing means to explicitly model typed references and dereferenciation in XML and semistructured data.

Regular graph grammars are usable as schema formalism for XML and semistructured data containing references (e.g. the translation of ACE sentences in XML as mentioned earlier in the context of VOXX) and as datatype formalism for typed variants of Xcerpt and XChange.

CaTTS is a static typed calendar and time language that allows for declarative modelling of various calendars (e.g. Gregorian calendar, business calendars, holiday calendars, etc.) as types and time tabling problems over calendar and time data defined by some CaTTS calendar using its object constraint language. CaTTS is designed to extend any programming language or (Semantic) Web query language (such as Xcerpt - cf. supra) in terms of a library integrated into its host language.

CaTTS is powerful and expressive enough to define most calendars in use today. The object constraint language of CaTTS enables declarative modelling of time tabling problems which will be solved by means of temporal constraint reasoning.

Reasoning on locations normally operates on a numerical level (e.g. coordinates) or on a symbolic level (e.g. graphs). Extensive research has been conducted in either case, hence there is a broad choice of proven sets of calculi and algorithms to solve the respective tasks. Whenever possible, reasoning should be conducted on higher level data, which is usually less heavy on the device's resources.

The fundamental insight is that many queries pertaining to location information are closely related to the problem of route planning and way-finding, which reduces the problem domain considerably. There are two reasons for this. (1) Whenever a certain location is sought after, chances are, that the inquirer intends to visit the location. Cases like these result in classic route planning tasks. (2) When people refer to the ``distance'' between two locations in the sense of locomotion, nearly never are they talking about distances per se (metres, kilometres) but the time needed to overcome these distances (``a ten minute walk'' or ``a half hour by train''). In fact, in many scenarios the exact distance between two points has a rather subordinate meaning from a traveller's viewpoint - especially in urban environments.

MPLL (Maple) aims for producing a set of reasoning techniques and for providing a framework for Sematic Web applications. This framework will include suitable data types and ontologies for processing and presenting location data.