Andreas Behrend

Soft stratification for magic set based query evaluation in deductive databases

In this paper we propose a new bottom-up query evaluation method for stratified deductive databases based on the Magic Set approach. As the Magic Sets rewriting may lead to unstratifiable rules, we propose to use Kerisits weak consequence operator to compute the well-founded model of magic rules (guaranteed to be two-valued). We show that its application in combination with the concept weak stratification, however, may lead to a set of answers which is neither sound nor complete with respect to the well-founded model. This problem is cured by introducing the new concept soft stratification instead.

Update Propagation in Deductive Databases Using Soft Stratification

Update propagation in deductive databases can be implemented by combining rule rewriting and fixpoint computation, analogous to the way how query answering is performed via Magic Sets. For efficiency reasons, bottom-up propagation rules have to be subject to Magic rewriting, thus possibly loosing stratifiability. We propose to use the soft stratification approach for computing the well-founded model of the magic propagation rules (guaranteed to be two-valued) because of the simplicity and efficiency of this technique.

Optimized incremental ETL jobs for maintaining data warehouses

ETL jobs are used to integrate data from distributed and heterogeneous sources into a data warehouse. A well-known challenge in this context is the development of incremental ETL jobs for efficiently maintaining warehouse data in the presence of source data updates. In this paper, we present a new transformation-based approach to automatically derive incremental ETL jobs. To this end, we consider a simplification of the underlying update propagation process based on the computation of so-called safe updates instead of true ones. Additionally, we identify the limitations of already proposed incremental solutions, which are cured by employing Magic Sets leading to dramatic performance gains.

Incremental view-based analysis of stock market data streams

In this paper we show the usefulness and feasibility of applying conventional SQL queries for analyzing a wide spectrum of data streams. As application area we have chosen the analysis of stock market data, mainly because this kind of application exhibits sufficiently many of those characteristics for which relational query technology can be considered a valuable instrument in a stream context. The resulting TInTo system is a tool for computing so-called technical indicators, numerical values calculated from a certain kind of stock market data, characterizing the development of stock prices over a given time period. Update propagation is used for the incremental recomputation of indicator views defined over a stream of continuously changing price data.

A transformation-based approach to view updating in stratifiable deductive databases

In this paper we present a new rule-based approach for consistency preserving view updating in deductive databases. Based on rule transformations performed during schema design, fixpoint evaluations of these rules at run time compute consistent realizations of view update requests. Alternative realizations are expressed using disjunctive Datalog internally. The approach extends and integrates standard techniques for efficient query answering and integrity checking (based on transformation techniques and fixpoint computation, too). Views may be stratifiably recursive. The set-orientedness of the approach makes it potentially useful in the context of (commercial) SQL systems, too.

CoDEL – A Relationally Complete Language for Database Evolution

Software developers adapt to the fast-moving nature of software systems with agile development techniques. However, database developers lack the tools and concepts to keep pace. Data, already existing in a running product, needs to be evolved accordingly, usually by manually written SQL scripts. A promising approach in database research is to use a declarative database evolution language, which couples both schema and data evolution into intuitive operations. Existing database evolution languages focus on usability but did not aim for completeness. However, this is an inevitable prerequisite for reasonable database evolution to avoid complex and error-prone workarounds. We argue that relational completeness is the feasible expressiveness for a database evolution language. Building upon an existing language, we introduce CoDEL. We define its semantic using relational algebra, propose a syntax, and show its relational completeness.

Continuous queries on trajectories of moving objects

Since navigation systems and tracking devices are becoming ubiquitous in our daily life, the development of efficient methods for processing massive sets of mobile objects are of utmost importance. Although future routes of mobile objects are often known in advance in many applications, this information is not fully utilized in most methods so far. In this paper, we reveal the beneficial effects of exploiting future routes for the early generation of the expected results of spatio-temporal queries. This kind of probable results is important for operative analytics in many applications like smart fleet management or intelligent logistics. For efficiently computing the high number of future trajectory points, a new index structure is presented which allows for a fast maintenance of query results under continuous changes of mobile objects. Our methods make use of specific update patterns, which require substantially less maintenance costs than the most general case of an update. A set of experiments based on a commonly used simulation environment shows the efficiency of our approach.

A case study in optimizing continuous queries using the magic update technique

The evaluation of continuous queries over data streams often becomes difficult as soon as static context data must be combined with dynamic stream data. This is especially the case if the context data is organized in form of view hierarchies and thus computed from some base facts. In this scenario, typical algebraic optimization strategies fail in providing a well-optimized query evaluation plan which effectively combines the stream and classical view subparts of the given query. The Magic Update method represents a possible solution to this problem as it allows for dynamically generating new selection conditions from the data stream which are pushed into the view hierarchy of context data. In this paper we present a case study in which the performance gain of this technique is shown when optimizing anomaly detection views in an air-traffic surveillance scenario.

Detecting Moving Objects in Noisy Radar Data Using a Relational Database

In moving object databases, many authors assume that number and position of objects to be processed are always known in advance. Detecting an unknown moving object and pursuing its movement, however, is usually left to tracking algorithms outside the database in which the sensor data needed is actually stored. In this paper we present a solution to the problem of efficiently detecting targets over sensor data from a radar system based on database techniques. To this end, we implemented the recently developed probabilistic multiple hypothesis tracking approach using materialized SQL views and techniques for their incremental maintenance. We present empirical measurements showing that incremental evaluation techniques are indeed well-suited for efficiently detecting and tracking moving objects from a high-frequency stream of sensor data in this particular context. Additionally, we show how to efficiently simulate the aggregate function product which is fundamental for combining independent probabilistic values but unsupported by the SQL standard, yet.

Living in Parallel Realities: Co-Existing Schema Versions with a Bidirectional Database Evolution Language

We introduce end-to-end support of co-existing schema versions within one database. While it is state of the art to run multiple versions of a continuously developed application concurrently, it is hard to do the same for databases. In order to keep multiple co-existing schema versions alive -- which are all accessing the same data set -- developers usually employ handwritten delta code (e.g. views and triggers in SQL). This delta code is hard to write and hard to maintain: if a database administrator decides to adapt the physical table schema, all handwritten delta code needs to be adapted as well, which is expensive and error-prone in practice. In this paper, we present InVerDa: developers use the simple bidirectional database evolution language BiDEL, which carries enough information to generate all delta code automatically. Without additional effort, new schema versions become immediately accessible and data changes in any version are visible in all schema versions at the same time. InVerDa also allows for easily changing the physical table design without affecting the availability of co-existing schema versions. This greatly increases robustness (orders of magnitude less lines of code) and allows for significant performance optimization. A main contribution is the formal evaluation that each schema version acts like a common full-fledged database schema independently of the chosen physical table design.