Marta Burzańska

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.

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.

Extending HQL with Plain Recursive Facilities

The mismatch between relational databases and object-oriented programming languages has been significantly mitigated by the use of object-relational mapping. However, the querying facilities available in such mapping systems are still inferior when compared to the features of a fully-fledged relational DBMS. In our research we aim at enriching object-relation mapping with advanced database concepts. An example of such an aspect is recursive querying. In prequel papers we have shown how to extend Hibernates mapping configurations with comprehendible recursive views that map to SQL common table expressions. In this paper we show how one can extend Hibernate Query Language (HQL) with plain recursive query facilities based on Oracles CONNECT BY phrase. Although, unfortunately it has not become a part of the SQL standard, its properties like cleanness and guaranteed stop make it worth exploiting.We propose adding CONNECT BY to HQL.We have implemented a prototype mapping of this phrase to recursive queries in major DBMSs and tested its efficiency. As the result we have got a simple, safe and fast way to pose recursive queries in HQL.

The Impedance Mismatch in Light of the Unified State Model

In this paper we discuss the misunderstanding that have arisen over the years around the broadly defined term of the object-relational impedance mismatch. It occurs in various aspects of database application programming. There are three concerns judged the most important: mismatching data models, mismatching binding times and mismatching object lifecycle. This paper focuses on the data model mismatch. We introduce the common state theory, i.e. a unified model of objects in popular programming languages and databases. The proposed model exploits and emphasizes common properties of all these objects. Using our model we demonstrate that there are notably more similarities than differences. We conclude that the impact of the mismatch of data models can be significantly reduced.

Intermediate Structure Reduction Algorithms for Stack Based Query Languages

Data processing often results in generation of a lot of temporary structures. They cause an increase in processing time and resources consumption. This especially concerns databases since their temporary data are huge and often they must be dumped to secondary storage. This situation has a serious impact on the query engine. An interesting technique of program fusion has been proposed for functional programming languages. Its goal is to reduce the size or entirely eliminate intermediate structures. In this paper we show how this technique can be used to generate robust execution plans of aggregate and recursive queries of query languages based on Stack Based Approach. We will use SBQL as an exemplary language.

How Poor Is the “Poor Man’s Search Engine”?

The modern world generates huge amounts of documents each day. Text data is ubiquitous in the digital space. They can contain information about products in an online store, the opinions of a blog author, reportage in a newspaper or questions and advice from online forums. Most of this data is managed using DBMS - mainly relational ones. Thus, the more crucial it becomes to find the most efficient use of the available text search mechanisms. This work examines the basic word search methods in the two of the most popular open DBMS: PostgreSQL and MariaDB. The results of the empirical tests will serve as a starting point for discussion is the “Poor Man’s Search Engine” SQL antipattern still an antipattern?

Supporting Code Review by Automatic Detection of Potentially Buggy Changes

Code reviews constitute an important activity in software quality assurance. Although they are essentially based on human expertise and scrupulosity, they can also be supported by automated tools. In this paper we present such a solution integrated with code review tools. It is based on a SVM classifier that indicates potentially buggy changes. We train such a classifier on the history of a project. In order to construct a training set, we assume that a change/commit is buggy if its modifications has been later altered by a bug-fix commit. We evaluated our approach on 77 selected projects taken from GitHub and achieved promising results. We also assessed the quality of the resulting classifier depending on the size of a project and the fraction of the history of a project that have been used to build the training set.

Open Source Is a Continual Bugfixing by a Few

Github is one of the most popular repository sites. It is a place where contributors come together to share code, ideas, thoughts and report issues. By using topic modelling applied to comments we are able to mine plentiful interesting information. Three aspects of an open source project mostly attracted our attention: the existence of a ”Core Team’” - small number of developers that have the most contributions, the prevailing popularity of topics related to bug fixing and the continuous development of project without significant iteration phases.

Level-oriented universal visual representation environment

We propose a three-dimensional graphics engine targeted at simultaneous visualizing multiple data sets and simulations in progress using a number of different visualization methods. The user can navigate between different views in a way in which one would traverse a museum: by switching focus from one object to another or zooming out to include several objects at the same time. Related visual-izations are vertically organized into levels or floors, further enhancing the museum metaphor. Additional information and means of manipulating the visualized data or simulations are provided for the user in a form of a two-dimensional on-screen overlay and also with the use of various input devices, not only mouse or keyboard. L.O.U.V.R.E. proved to be a very efficient and useful tool when dealing with experiments on robotics simulations. This paper presents such usage, and al-so indicates other possible applications. We find that it fills a gap as an intuitive solution encompassing graphing, simulation and user interface at the same time. Its applications go far beyond computer science research into such fields as biology or physics.