Hanna Kozankiewicz

Updatable XML Views

XML views can be used in Web applications to resolve incompatibilities among heterogeneous XML sources. They allow to reduce the amount of data that a user has to deal with and to customize an XML source. We consider virtual updatable views for a query language addressing an XML native database. The novelty of the presented mechanism is inclusion of information about intents of updates into view definitions. This information takes the form of procedures that overload generic view updating operations. The mechanism requires integration of queries with imperative (procedural) statements and with procedures. This integration is possible within the Stack-Based Approach to query languages, which is based on the classical concepts of programming languages such as the environment stack and the paradigm of naming/scop-ing/binding. In the paper, we present the view mechanism describing its syntax, semantics and discussing examples illustrating its possible applications.

Integration of heterogeneous resources through updatable views

We propose a new approach to integration of distributed heterogeneous resources on the basis of a canonical object-oriented database model, a query language and updateable database views. Views are used as wrappers/mediators on top of local servers and as a data integration facility for global applications. Views support location, implementation and replication transparency. Because views are defined in a high-level query language, the mechanism is much more abstract and flexible in comparison to CORBA, Web services, etc. The paper presents a short introduction to the query language SBQL and updateable views. It also presents the architecture of the grid network based on updateable views, and simple examples illustrating the mechanism.

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.

Implementation of federated databases through updatable views

We present a new approach to the grid technology that is based on federated databases and updatable views. Views are used in two ways: (1) as wrappers of local servers that adopt local schemata to the federated database requirements; (2) as a facility for data integration and transformation into a canonical form according to the federated database schema. Views deliver virtual updatable objects to global clients. These objects can be associated with methods that present the procedural part of remote services, like in Web Services. The fundamental quality of the approach is transparency of servers: the user perceives the distributed environment of objects and services as an integrated virtual whole. The approach is based on a very simple and universal architecture and on the stack-based approach, which treats query languages as a kind of programming language.

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.

Transparency in object-oriented grid database systems

The paper presents various transparency issues that have to be considered during development of object-oriented Grid applications based on virtual repositories. Higher-level transparencies, such as location, heterogeneity, fragmentation, replication, redundancy, indexing and service provider transparency assure new information processing culture greatly supporting the development, operation and maintenance of Grid database applications. The paper discusses some requirements for a virtual repository that is a kernel of a Grid database and a general architecture of such systems. The architecture is based on object-oriented updatable database views that serve, in particular, as adapters of local servers and integrators/mediators on the level of a global virtual repository. Finally, some issues of the development of Grid database applications are presented.

Intelligent data integration middleware based on updateable views

We present a new approach to the grid technology which is based on updateable views. Views are used in two ways: (1) as wrappers of local servers which adopt local schemata to the federated database requirements; (2) as a facility for intelligent data integration and transformation into a canonical form according to the federated database schema. Views deliver virtual updatable objects to global clients. Objects can be associated with methods which present the procedural part of remote services, like e.g., in Web Services. The fundamental quality of the approach is transparency of servers: the user perceives the distributed data/service environment as an integrated virtual whole. Such a quality is achieved by applications based on CORBA. We attempt to achieve a higher level of transparency by providing means for integrating horizontal and vertical fragmentations of data and by taking into account various forms of data redundancy. The approach is based on a very simple and universal architecture and on the stack-based approach (SBA) to object-oriented query languages.

Optimization of queries invoking views by query tail absorption

A widely recognized method to optimize queries invoking virtual views is query modification. The method is based on macro-substitution, where a view invocation is textually unfolded within a query and then optimized together with the query. For complex SBQL views this method is not always applicable because a view can depend on some private server resources (thus it cannot be sent to the client side) or a view is defined by a complex algorithm (thus the view cannot be unfolded within a query). For such cases we propose a reverse technique which assumes absorption of a part of the client query (a query tail) by a view definition and then, optimization of the definition. The technique has the same potential as query modification, but it is less constrained. In the paper we illustrate both techniques on examples and present some architectural peculiarities of the new method.

Implementing a P2P network through updatable database views

We present a novel approach to implement a business-oriented peer-to-peer network through updatable object views. We assume that each peer maintains an integrating view through which it can access the resources made public by all the peers. Each peer keeps also another view which makes some of its local resources public.