  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.
