Kazimierz Subieta

Distributed query optimization in the stack-based approach

We consider query execution strategies for object-oriented distributed databases. There are several scenarios of query decomposition, assuming that the corresponding query language is fully compositional, i.e. allows decomposing queries into subqueries addressing local servers. Compositionality is a hard issue for known OO query languages such as OQL. Thus we use the Stack-Based Approach (SBA) and its query language SBQL, which is fully compositional and adequate for distributed query optimization. We show flexible methods based on decomposition of SBQL queries in a distributed environments. Decomposition can be static or dynamic, depending on the structure of the query and distribution of data. The paper presents only the main assumptions, which are now the subject of our study and implementation.

Object-Oriented wrapper for relational databases in the data grid architecture

The paper presents a solution of the problem of wrapping relational databases to an object-oriented business model in the data grid architecture. The main problem with this kind of wrappers is how to utilize the native SQL query optimizer, which in majority of RDBMS is transparent for the users. In our solution we use the stack-based approach to query languages, its query language SBQL, updateable object-oriented virtual views and the query modification technique. The architecture rewrites the front-end OO query to a semantically equivalent back-end query addressing the M0 object model that is 1:1 compatible with the relational model. Then, in the resulting SBQL query the wrapper looks for patterns that correspond to optimizable SQL queries. Such patterns are then substituted by dynamic SQL execute immediately statements. The method is illustrated by a sufficiently sophisticated example. The method is currently being implemented within the prototype OO server ODRA devoted to Web and grid applications.

Modeling object views in distributed query processing on the grid

This paper proposes a method for modeling views in Grid databases. Views are understood as independent data transformation services that may be integrated with other Database Grid Services. We show examples of graphical notation and semi-automated query construction. The solution is supported by a minimal metamodel, which also provides reflection capabilities for dynamic services orchestration.

Optimization of distributed queries in grid via caching

Caching can highly improve performance of query processing in distributed databases. In this paper we show how this technique can be used in grid architecture where data integration is implemented by means of updatable views. Views integrate data from heterogeneous sources and provide users with their integrated form. The whole process of integration is transparent, i.e. users need not be aware that data are not located at one place. In data grids caching can be used at different levels of architecture. We focus on caching at the middleware layer where the cache is stored in the database of the integrating unit. These results can be then used while answering queries from grid users, so there will be no need to reevaluate the whole queries. In such a way caching can highly increase performance of applications operating on grid. In the paper we also present an example how a query can be optimized by rewriting to make use of cached results.

Usability of visual information retrieval metaphors for object-oriented databases

We present visual metaphors of Mavigator, a visual information retrieval system for Web-oriented database applications. The metaphors allow the naive users (computer non-professionals) to retrieve information from object-oriented databases in an easy and intuitive form. Novel features of Mavigator include coherent combination of a few paradigms: intentional navigation, extensional navigation, baskets for recording retrieval results and active extensions. The latter are programmed in a programming language thus allow a programmer to extend functionalities available to end users with no limitations. Due to the flexible architecture Mavigator is able to work not only with a proprietary object-oriented database but also with any information source. The objective of the corresponding PhD thesis is investigation into usability of different visual retrieval metaphors in realistic Web applications. In this paper we present some of the metaphors and discuss their potential for users.

Usable recursive queries

Recursive queries are required for many tasks of database applications. Among them we can mention Bill-Of-Material (BOM), various kinds of networks (transportation, telecommunication, etc.), processing semi-structured data (XML, RDF), and so on. The support for recursive queries in current query languages is limited. In particular, this concerns corresponding extensions of SQL in Oracle and DB2 systems. In this paper we present recursive query processing capabilities for the object-oriented Stack-Based Query Language (SBQL). SBQL offers very powerful and flexible recursive querying capabilities due to the fact that recursive processing operators are fully orthogonal to other capabilities of this language. The presented features aim at the ease of recursive programming in databases and not at building new theoretical foundations. This paper discusses novel SBQL constructs, such as transitive closures, fixed point equations and recursive procedures/views. Their main advantage is that they are seamlessly integrated with object-oriented facilities, computer environment and databases.

Active Extensions in a Visual Interface to Databases

The retrieval capabilities of the visual information retrieval system Mavigator have been designed for a naive user, typically a computer nonprofessional. In contrast to retrieval engines on raw text (such as Google), Mavigator addresses structured data (e.g. XML repositories). For such data a query language is proper, however naive users cannot deal with sophisticated retrieval methods and metaphors, especially using keyboardoriented languages a la SQL and script languages for formatting retrieval output. There are two options: some generic output format (e.g. a table), which is usually too restrictive for the users, or some attractive visual form (e.g. a function chart), which in tum must be specialized to a particular application and retrieval kind. Some tradeoff between these extremes is necessary.

Tier aspect model based on updatable views

The tier aspect model addresses Aspect Oriented Programming (AOP) in the context of database applications. It is a new technique of separation of concerns through tiers implemented as virtual object-oriented updatable views. The code of an aspect related to particular objects is encapsulated within a separate view that overrides all generic operations performed on the objects. Aspect tiers form a chain of views. Such additional codes can do any extra action e.g. security, licensing, integrity constraints, monitoring and others. The idea is based on the Stack-Based Approach to object-oriented query languages and the novel idea of virtual updatable views.

A flexible grid infrastructure for data analysis

In this paper we present a novel infrastructure for data analysis based on the mechanism of updatable views. The views are used in two ways: as wrappers of local servers, which allow one to adopt local schemata to warehousing requirements, and as a facility for data integration and transformation to a federated canonical data model. Such updatable views present virtual data to the clients, but they themselves are also objects that can have methods and other features. The advantage of our approach is a simple architecture and a user-friendly query language for definition of views and for writing applications. Thus our approach can compete with Web Services, CORBA and other middleware technologies in terms of universality, flexibility and maintainability. This approach is based on the Stack-Based Approach to query languages, in which the query language is treated as a kind of programming languages.