Optimal Planar Range Skyline Reporting with Linear Space in External Memory

TL;DR

This paper introduces optimal linear-space data structures for answering range skyline queries in external memory, achieving near-optimal I/O performance for various query types, and establishes complexity bounds for more challenging query variants.

Contribution

It presents the first linear-size external memory data structures with optimal I/O bounds for top-open and 3-sided skyline queries, and proves complexity lower bounds for left- and bottom-open queries.

Findings

Top-open queries can be answered in O(log_B(n) + k/B) I/Os.

Data points on a U x U grid enable faster query times, down to O(1 + k/B).

Left- and bottom-open queries are proven to be inherently harder, matching the complexity of general 4-sided queries.

Abstract

Let P be a set of n points in R^2. Given a rectangle Q = [\alpha_1, \alpha_2] x [\beta_1, \beta_2], a range skyline query returns the maxima of the points in P \cap Q. An important variant is the so-called top-open queries, where Q is a 3-sided rectangle whose upper edge is grounded at y = \infty (that is, \beta_2 = \infty). These queries are crucial in numerous database applications. In internal memory, extensive research has been devoted to designing data structures that can answer such queries efficiently. In contrast, currently there is no clear understanding about their exact complexities in external memory. This paper presents several structures of linear size for answering the above queries with the optimal I/O cost. We show that a top-open query can be solved in O(log_B(n) + k/B) I/Os, where B is the block size and k is the number of points in the query result. The query cost can be made O(log log_B(U) + k/B) when the data points lie in a U x U grid for some integer U >= n, and further lowered to O(1 + k/B) if U = O(n). The same efficiency also applies to 3-sided queries where Q is a right-open rectangle. However, the hardness of the problem increases if Q is a left- or bottom-open 3-sided rectangle. We prove that any linear-size structure must perform \Omega((n/B)^\eps + k/B) I/Os to solve such a query in the worst case, where \eps > 0 can be an arbitrarily small constant. In fact, left- and right-open queries are just as difficult as general (4-sided) queries, for which we give a linear-size structure with query time O((n/B)^\eps + k/B). Interestingly, this indicates that 4-sided range skyline queries have exactly the same hardness as 4-sided range reporting (where the goal is to report simply the whole P \cap Q). That is, the skyline requirement does not alter the problem difficulty at all.