Krzysztof Stencel

Detection of Diverse Design Pattern Variants

We propose a method for automatic detection of occurrences of design patterns. We also describe its proof-of-concept implementation and the results of comparative experiments with other tools. The method presented here is able to detect many nonstandard implementation variants of design patterns, while its efficiency is comparable to other state-of-the-art detection tools. Moreover, the method is highly customizable because an analyst can introduce a new pattern retrieval query or modify an existing one and then repeat the detection using the results of earlier source code analysis stored in a relational database.

Recursive Query Facilities in Relational Databases: A Survey

The relational model is the basis for most modern databases, while SQL is the most commonly used query language. However, there are data structures and computational problems that cannot be expressed using SQL-92 queries. Among them are those concerned with the bill-of-material and corporate hierarchies. A newer standard, called the SQL-99, introduced recursive queries which can be used to solve such tasks. Yet, only recently recursive queries have been implemented in most of the leading relational databases. In this paper we have reviewed and compared implementations of the recursive queries defined by SQL:1999 through SQL:2008 and offered by leading vendors of DBMSs. Our comparison concerns features, syntax and performance.

Software is a directed multigraph

The architecture of a software system is typically defined as the organization of the system, the relationships among its components and the principles governing their design. By including artifacts coresponding to software engineering processes, the definition gets naturally extended into the architecture of a software system and process. In this paper we propose a holistic model to organize knowledge of such architectures. This model is graph-based. It collects architectural artifacts as vertices and their relationships as edges. It allows operations like metric calculation, refactoring, bad smell detection and pattern discovery as algorithmic transformations on graphs. It is independent of development languages. It can be applied for both formal and adaptive projects. We have implemented prototype tools supporting this model. The artifacts are stored in a graph database. The operations are defined in a graph query language. They have short formulation and are efficiently executed by the graph database engine.

Pushing Predicates into Recursive SQL Common Table Expressions

A recursive SQL-1999 query consists of a recursive CTE (Common Table Expression) and a query which uses it. If such a recursive query is used in a context of a selection predicate, this predicate can possibly be pushed into the CTE thus limiting the breadth and/or depth of the recursive search. This can happen e.g. after the definition of a view containing recursive query has been expanded in place. In this paper we propose a method of pushing predicates and other query operators into a CTE. This allows executing the query with smaller temporary data structures, since query operators external w.r.t. the CTE can be computed on the fly together with the CTE. Our method is inspired on the deforestation (a.k.a. program fusion) successfully applied in functional programming languages.

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.

Optimization of object-oriented queries addressing large and small collections

When a query jointly addresses very large and very small collections it may happen that an iteration caused by a query operator is driven by a large collection and in each cycle it evaluates a subquery that depends on an element of a small collection. For each such element the result returned by the subquery is the same. In effect, such a subquery is unnecessarily evaluated many times. The optimization rewrites such a query to reverse the situation: the loop is to be performed on a small collection and inside each its cycle a subquery addressing a large collection is evaluated. We illustrate the method on comprehensive examples and then present the general rewriting rule. The research follows the Stack-Based Approach to query languages having roots in the semantics of programming languages. The optimization method consists in analyzing of scoping and binding rules for names occurring in queries.

Implementation Variants of the Singleton Design Pattern

We present a study of different implementation variants of the Singleton pattern and propose an intuitive definition of this pattern expressed as a first-order logic formula. We also show that our method for automatically detecting design patterns can be used to detect instances of the Singleton with respect to this definition. We also provide data on experiments with a proof-of-concept implementation of this detection method. These experiments prove the efficiency and high accuracy of the method, which is able to detect many non-standard variants of the Singleton in real source code.

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.

Efficient implementation of recursive queries in major object relational mapping systems

The following paper presents the effects of combining two technologies: object-relational mapping and SQLs recursive queries. Both technologies are widely used in modern software, and yet, modern ORM systems still lack the support for recursive database querying. The currently used methods for querying graph and hierarchical structures are either inefficient, difficult to maintain, or do not allow for any portability. The authors of the following paper propose extensions to the general functionality of modern ORM systems and present the results for two ORM systems: Hibernate for Java and Django-models for Python. With this extension programmers using one of those systems can benefit from the support for the recursive queries offered by various object-relational database management systems and write a maintainable code compliant with the used ORM standard. The proposed solution works with IBM DB2, Oracle and PostgreSQL DBMS and proved to be many times faster than the approaches currently used.