Efficient concurrency control in multidimensional access methods

This paper presents general algorithms for concurrency control in tree-based access methods as well as a recovery protocol and a mechanism for ensuring repeatable read. The algorithms are developed in the context of the Generalized Search Tree (GiST) data structure, an index structure supporting an extensible set of queries and data types. Although developed in a GiST context, the algorithms are generally applicable to many tree-based access methods. The concurrency control protocol is based on an extension of the link technique originally developed for B-trees, and completely avoids holding node locks during I/Os. Repeatable read isolation is achieved with a novel combination of predicate locks and two-phase locking of data records. To our knowledge, this is the first time that isolation issues have been addressed outside the context of B-trees. A discussion of the fundamental structural differences between B-trees and more general tree structures like GiSTs explains why the algorithms developed here deviate from their B-tree counterparts. An implementation of GiSTs emulating B-trees in DB2/Common Server is underway.

This chapter introduces a concurrency control algorithm based on link-technique for high-dimensional index structures. In high-dimensional index structures, search operations are generally more frequent than insert or delete operations and need to access many more nodes than those in other index structures, such as B+-tree, B-tree, hashing techniques, and so on, due to the properties of queries. This chapter proposed an algorithm that minimizes the delay of search operations in all cases. The proposed algorithm also supports concurrency control on reinsert operations for the high-dimensional index structures employing reinsert operations to improve their performance. The authors hope that this chapter will give helpful information for studying multidimensional index structures and their concurrency control problems to researchers.

Indexes are used in database management systems as a mechanism to speed up data retrieval. A good index structure should ensure that the data access through it is efficient and transactional. For one dimensional data, the B+-tree and its variants, such as the Blink-Tree and the π,-tree, are used widely because of their good query performance and concurrency control and recovery. However, structures for multidimensional data, despite the intense research for more than two decades, have not been so successful. Very few of the many proposed structures are implemented in commercial databases. For those that have been used, users are confronted with either poor performance or low concurrency. We proposed a new spatial access method called the Spatial C-Tree. Our approach extends the C-Tree framework, which provides efficient concurrency control and robust recovery mechanism. We have implemented the Spatial C-Tree and compared it with several R-Tree variants. Our performance results show that the Spatial C-Tree performs very well in terms of insertion and exact match queries with various data sets. Our range query performance in some cases is comparable to the R-Tree variants and in other cases are outperformed by the R-Tree variants. We have identified possible improvements over the range query performance. The potential improvement on the range query performance and the high concurrency guarantee make the Spatial C-Tree a promising access method for spatial data.

On-line analytical processing (OLAP) is a technology that encompasses applications requiring a multidimensional and hierarchical view of data. OLAP applications often require fast response time to complex grouping/aggregation queries on enormous quantities of data. Commercial relational database management systems use mainly multiple one-dimensional indexes to process OLAP queries that restrict multiple dimensions. However, in many cases, multidimensional access methods outperform one-dimensional indexing methods.We present an architecture for multidimensional databases that are clustered with respect to multiple hierarchical dimensions. It is based on the star schema and is called CSB star. Then, we focus on heuristically optimizing OLAP queries over this schema using multidimensional access methods. Users can still formulate their queries over a traditional star scheme, which are then rewritten by the query processor over the CSB star. We exploit the different clustering features of the CSB star to efficiently process a class of typical OLAP queries. We detect special cases where the construction of an evaluation plan can be simplified and we discuss improvements of our technique.

The use of Spatial Access Methods (SAMs) in spatial database systems, such as Geographical Information Systems, is necessary to achieve efficient retrieval of data items according to their spatial properties. Existing SAMs organizing minimum bounding rectangle (MBR) approximations of spatial objects can be classified into four groups. Each group is characterized by the special technique adopted for managing MBRs: (a) Ordering, (b) Transformation, (c) Clipping, and (d) Overlapping. This paper introduces a new technique. The basic idea of this technique is to represent all spatial objects by their MBRs and further reduce them into points of the same dimensionality, so that any multidimensional Point Access Method (PAM) may be used to support access. Essential for the functionality of the new method is the query window extension. The results of both analytical and experimental work show that SAMs using the new technique clearly outperform popular SAMs, such as the R- and R*-trees for data sets consisting of equal-sized MBRs. As for data sets of varying MBR sizes a competitive performance can be obtained.

An efficient index structure for complex multi-dimensional objects is one of the most challenging requirements in non-traditional applications such as geographic information systems, computer-aided design, and multimedia databases. In this paper we first propose a main memory data structure for complex multi-dimensional objects. Then, we present an extension of the existing multi-dimensional index structure. Among existing multi-dimensional index structures, the popular Ra-tree is selected. The Ra-tree is coupled with the main memory data structure to improve the performance of spatial query processing. An analytical model is developed for our index structure. Experimental results show that the analytical model is accurate, the relative error being below 15%. The performance of our index structure is compared with that of a state-of-the-art index structure by experimental measurements. Our index structure outperforms the state-of-the-art index structure due to its ability to reduce a large amount of storage.

Similarity search is fundamental to store and retrieve large volumes of complex data required by many real world applications. A useful mechanism for such concept is the query-by-similarity. Based on their topological properties, metric similarity functions can be used to index sets of data which can be queried effectively and efficiently by the so-called metric access methods. However, data produced by various application domains and the varying data types handled often lead to missing data, hence, they do not follow the metric similarity requirements. As a consequence, missing data cause distortions in the index structure and yield bias in the query answer. In this paper, we propose the Hollow-tree, a novel access method aimed at successfully retrieving data with missing attribute values. It employs new strategies for indexing and searching data elements, capable of handling the missing data issues when the cause of missingness is ignorable. The indexing strategy is based on a family of distance functions that allow measuring the distance between elements with missing values, along with a set of policies able to organize the elements in the index without causing distortions to its internal structure. The searching strategy employs fractal dimension property of the data to achieve accurate query answer while considering data with missing values part of the response. Results from experiments performed on a variety of real and synthetic data sets showed that, while other metric access methods deteriorate with small amounts of missing values, the Hollow-tree maintains a remarkable performance with almost 100% of precision and recall for range queries and more than 90% for k-nearest neighbor queries, for up to 40% of missing values.

It is frequently the case that spatial queries require a result set of objects whose - however this may be more precisely defined - is the same as that of the query window. In this paper we present an approach which considerably improves query performance in such cases. By adding a dimension to the schema we make the index structure explicitly aware of the of a spatial object. The additional dimension causes the index structure to cluster objects not only by geographic location but also by scale. By matching scales of the query window and the objects, the query then automatically considers only relevant objects. Thus, for example, a query window encompassing an entire world map of political boundaries might return only national borders. Note that scale is not necessarily synonymous with size. This approach improves performance by both narrowing the initial selection criteria and by eliminating the need for subsequent filtering of the query result. In our performance measurements on databases with up to 40 million spatial objects, the introduction of a dimension decreased I/O by up to 4 orders of magnitude. The performance gain largely depends on the object distribution.We investigate a broad set of parameters that affect performance and show that many typical applications could benefit considerably from this technique. Its scalability is demonstrated by showing that the benefit increases with the size of the query and/or of the database. The technique is simple to apply and can be used with any multidimensional index structure that can index spatial extents and can be efficiently generalized to three or more dimensions. In our tests we have used the BANG index structure.

Conventional spatial indexes, represented by the R-tree, employ multidimensional tree structures that are complicated and require enormous efforts to implement in a full-fledged database management system (DBMS). An alternative approach for supporting spatial queries is mapping-based indexing, which maps both data and queries into a one-dimensional space such that data can be indexed and queries can be processed through a one-dimensional indexing structure such as the B + . Mapping-based indexing requires implementing only a few mapping functions, incurring much less effort in implementation compared to conventional spatial index structures. Yet, a major concern about using mapping-based indexes is their lower efficiency than conventional tree structures. In this article, we propose a mapping-based spatial indexing scheme called Size Separation Indexing (SSI). SSI is equipped with a suite of techniques including size separation, data distribution transformation, and more efficient mapping algorithms. These techniques overcome the drawbacks of existing mapping-based indexes and significantly improve the efficiency of query processing. We show through extensive experiments that, for window queries on spatial objects with nonzero extents , SSI has two orders of magnitude better performance than existing mapping-based indexes and competitive performance to the R-tree as a standalone implementation. We have also implemented SSI on top of two off-the-shelf DBMSs, PostgreSQL and a commercial platform, both having R-tree implementation. In this case, SSI is up to two orders of magnitude faster than their provided spatial indexes. Therefore, we achieve a spatial index more efficient than the R-tree in a DBMS implementation that is at the same time easy to implement. This result may upset a common perception that has existed for a long time in this area that the R-tree is the best choice for indexing spatial objects.

This paper presents an original information-retrieval engine, called MIRE, for integrating structured data and text. Among other things, MIRE is designed to work in a natural and efficient way with the inherent hierarchies of structured data. While multidimensional access methods have originally been developed for spatial applications, they can be successfully used to index hierarchical structured data and add to an existing information retrieval engine the capability of navigating hierarchical dimensions. To support this capability, MIRE enhances the processing algorithms of an existing multidimensional access method to avoid overflow and support for hierarchical dimensions. Compared to a search engine with multiple indexes for a different type of search, the multidimensional approach shows a significant reduction in the number of page accesses over a large document collection.

Branch-and-bound processing of ranked queries

Given an integer k, a representative skyline contains the k skyline points that best describe the tradeoffs among different dimensions offered by the full skyline. Although this topic has been previously studied, the existing solution may sometimes produce k points that appear in an arbitrarily tiny cluster, and therefore, fail to be representative. Motivated by this, we propose a new definition of representative skyline that minimizes the distance between a non-representative skyline point and its nearest representative. We also study algorithms for computing distance-based representative skylines. In 2D space, there is a dynamic programming algorithm that guarantees the optimal solution. For dimensionality at least 3, we prove that the problem is NP-hard, and give a 2-approximate polynomial time algorithm. Using a multidimensional access method, our algorithm can directly report the representative skyline, without retrieving the full skyline. We show that our representative skyline not only better captures the contour of the entire skyline than the previous method, but also can be computed much faster.

In spatial database applications the similarity or dissimilarity of complex objects is examined by performing distance-based queries (DBQs) on data of high dimensionality (a generalization of spatial data). The R-tree and its variations are commonly cited as multidimensional access methods that can be used for answering such queries. Although the related algorithms work well for low-dimensional data spaces, their performance degrades as the number of dimensions increases (dimensionality curse). To obtain acceptable response time in high-dimensional data spaces, algorithms that obtain approximate solutions can be used. In this chapter, we review the most important approximation techniques for reporting sufficiently good results quickly. We focus on the design choices of efficient approximate DBQ algorithms that minimize the response time and the number of I/O operations over tree-like structures. The chapter concludes with possible future research trends in the approximate computation of DBQs.

We present an access method designed to provide a single integrated index structure for a versioned timestamped database with a non-deletion policy. Historical data (superceded versions) is stored separately from current data. Our access method is called the Time-Split B-tree. It is an index structure based on Malcolm Easton's Write Once B-tree.

The architecture of Geographic Information Systems (GISs) is changing: more and more systems are based on the integrated architecture, i.e. storing geometric data in the Data Base Management System (DBMS) together with administrative data. The first step in building a Geo-DBMS is by having data types and operators for simple features (i.e. geometric primitives): point, line and polygon. This has reached a level of standardisation and is now implemented in several commercial DBMSs. The next step is to have support for the topologically structured features in the DBMS, i.e. complex features. The DBMS can then check and guarantee consistency. In addition, complex operations can be executed within the DBMS. Despite the fact that topologically structured models are well known and that it is not difficult to store the topological references, it still remains an unresolved issue as to how to effectively implement these models within a relational DBMS. In this paper, we describe the design and implementation of a topologically structured management at the DBMS level. Our focus is to translate topological structures into geometric primitives. It is then possible to define a DBMS view on a topological primitive, which makes this appear as a geometric primitive. This process supports the best of both worlds: on the one hand there are advantages of the topological structure (no redundancy) and on the other hand the ease of explicit geometric primitives in querying, analysis and presentation is available.