A survey on making skylines more flexible

As mentioned before, one of the major shortcomings of skylines is customization. The skyline of a dataset does not depend on any kind of parameter, only on the dataset itself. As a result, the skyline query can not be customized in any way. $F$-skylines are a generalization of the skyline that introduces a parameter to the query while compromising very little from the simplicity of skyline queries [3].

Before we define what an $F$-skyline is, let us define $F$-domination. A tuple $r_{1}$ $F$-dominates another tuple $r_{2}$ if and only if $r_{1}$ is at least as good as $r_{2}$ for all scoring functions in $F$ and better than $r_{2}$ for at least one scoring function. In formal terms:

$$r_{1}\prec r_{2}\iff\forall f\in F.\ f(r_{1})\leq f(r_{2})\land\exists f\in F.f(r_{1})<f(r_{2})$$

If $F$ is the set of all monotonic functions, $F$-domination reduces to Pareto domination.

Given a dataset $R$ and a set of monotone scoring functions $F$, the two flexible skyline operators are defined as follows:

$$ND(R,F):=\{r\in R\ |\ \nexists t\in R.\ t\prec_{F}r\}$$

$$PO(R,F):=\{r\in R\ |\ \exists f\in F,\forall r^{\prime}\in r.\ f(r)\leq f(r^{\prime})\}$$

The first operator, $ND$, denotes all non $F$-dominated tuples of $R$ and the second operator, $PO$, denotes the tuples in $R$ that are optimal for at least one of the functions in $F$. When $F$ is the set of all monotonic functions, both $ND(R,F)$ and $PO(R,F)$ converge to the skyline of $R$. However, in the general case, they are not necessarily equal [3].

$ND$ and $PO$ are both customizable since they have an additional parameter, $F$, that enables customized queries. In addition, they partially address the other shortcoming of skylines, they lower the output cardinality for non-universal choices of $F$. One can show $PO(R,F)\subseteq ND(R,F)\subseteq SKY(R)$ for all choices of $R$ and $F$. Thus guaranteeing neither $ND$, nor $PO$ will have a greater cardinality than the skyline. Experimental results [3] depict that the cardinality of $ND$ is dramatically lower than the skyline even with only a few constraints on $F$ and the cardinality of $PO$ is even lower.

Customizability and control over result cardinality, the two properties flexible skylines provide, are already available in top-$k$ queries, although flexible skylines do not require precisely defined scoring functions as top-$k$ queries do. As an example, consider a simplified universe of functions comprising only weighted sums over the attributes with normalized weights, functions of the form $f(r)=\sum{w_{i}r_{i}}$ where $r_{i}$ denotes an attribute in the schema of $R$. A top-$k$ query would need to specify a precise scoring function (or equivalently, a precise vector $w$) but a flexible skyline allows less precise queries such as $F=\{f(r)=w_{1}r_{1}+w_{2}r_{2}\ |\ w_{1}>2w_{2}\}$. Such constraints are significantly easier to obtain [12]. For instance, if a user prefers the tuple $(2,3)$ to $(1,6)$, we can argue:

$$2w_{1}+3w_{2}<w_{1}+6w_{2},\ i.e.,$$

$$w_{1}<3w_{2}$$

Flexible skylines merge the idea of scoring functions of top-$k$ queries with traditional skylines. This is further illustrated by the fact that choosing $F$ to be the set of all monotonic functions reduces both operators to the traditional skyline but choosing it to contain a single monotonic function reduces them to the top-1 query result. By combining the two approaches, flexible skylines are both easy to specify and customizable at the same time.

The two flexible operators are discussed only for skylines here for brevity, but [11] and [2] extend this notion to $k$-skybands to provide a more generalized framework.

Another solution approach [10] to the same problem introduces the notion of $\rho$-dominance and two operators that utilize this relation to provide types of queries that are not as precise as top-$k$ queries but still have query customization and smaller output cardinality than the skyline. In fact, these operators allow specifying the cardinality of their output as a parameter.

These operators only use weighted sums over attributes with normalized preferences as scoring functions. They define a new kind of dominance, much like $F$-dominance. Given an estimate preference vector $w$ and tuples $r_{1},r_{2}$, $r_{1}$ $\rho$-dominates $r_{2}$ if the following conditions are satisfied:

1. 1.

   $\forall v\in\Delta^{d-1}.\ |w-v|\leq\rho\implies\sum_{i}{v_{i}{r_{1}}_{i}\leq\sum_{i}{v_{i}{r_{2}}_{i}}}$

2. 2.

   $\exists v\in\Delta^{d-1}.\ |w-v|\leq\rho\land\sum_{i}{v_{i}{r_{1}}_{i}<\sum_{i}{v_{i}{r_{2}}_{i}}}$

In other words, they relax the normalized preference vector $w$ up to a distance of $\rho$ and check dominance for every preference vector inside the resulting hypersphere. If a $r_{1}$ performs at least as good as $r_{2}$ for all vectors and better than $r_{2}$ for at least one, $r_{1}$ $\rho$-dominates $r_{2}$, much like the concept of domination in flexible skylines.

The first output size specified operator is called $ORD$, it is Output size specified, has relaxed input and is dominance oriented. Given an estimate preference vector $w$, an output size $m$ and a dataset $R$, $ORD(R,w,m)$ denotes $m$ tuples in $R$ that are not $\rho$-dominated for the minimum value of $\rho$ that allows $m$ tuples.

The second output size specified operator is $ORU$, again because it is Output size specified, has relaxed input and it is utility-oriented. $ORU(R,w,m)$ denotes $m$ tuples in $R$ that are optimal for at least one preference vector with a maximum distance of $\rho$ from $w$.

Both of these operators can be further generalized by relaxing $ORD$ to contain tuples that are dominated by fewer than $k$ others and relaxing $ORU$ to contain tuples that are in the top-$k$ result for at least one vector.

This approach is very similar to flexible skylines. In fact, for any preference vector $v$ and distance $\rho$, weighted sums with weight vectors inside the hypersphere centered around $v$ with radius $\rho$ specifies a set of functions $F$. In fact, for any dataset $R$, non-$\rho$-dominated tuples in $R$ are precisely $ND(R,F)$ and tuples that are optimal for at least one vector are precisely $PO(R,F)$.

Another parallel method that addresses the problem of relaxing the input preference vector is uncertain top-$K$ (UTK) queries [11]. Similar to OSS operators, these queries only consider weighted sums over the attributes as scoring functions. Likewise, each UTK query operates on a set of possible preference vectors rather than a single vector and these possible preference vectors form a convex polytope in the $d-1$ dimensional simplex. Instead of specifying the region of possible vectors via a central vector and a radius, UTK queries allow the region to be specified as a parameter on its own.

[11] defines two different UTK operators, $UTK_{1}$ and $UTK_{2}$. Given a $d$ dimensional dataset $R$, a desired output cardinality $k$ and a preference region $P\subseteq\Delta^{d-1}$, $UTK_{1}(k,R,P)$ contains the tuples in $R$ that are in the top-$k$ result for a preference vector in $P$ and $UTK_{2}(k,R,P)$ partitions $P$ so that vectors in each partition produce the same top-$k$ result and labels the partitions with the top-$k$ results they correspond to.

UTK queries can express a larger family of scoring functions than OSS operators since every $d-1$ dimensional hypersphere is a $d-1$ dimensional polytope but the converse is not true. However, flexible skylines can express an even larger family of scoring functions since UTK is still limited to functions that are linear in the tuple attributes.

The sets of tuples computed by $UTK_{1}$ queries correspond to the tuples computed by $PO$ and $ORU$ operators for matching inputs. Since $UTK$ queries only check optimality and not domination, $ND$ and $ORD$ can not be computed by $UTK$ queries.

$\epsilon$-skylines [14] is one of the earlier approaches to addressing the shortcomings of top-$k$ and skyline queries. Similar to OSS operators, $\epsilon$-skylines only consider weighted sums as scoring functions. They use the notion of $\epsilon$-dominance, which, given a dataset $R$, a normalized preference vector $w$ and a constant $\epsilon\in[-1,1]$ is defined as:

$$r_{1}\prec_{\epsilon}r_{2}\iff(\forall i.w_{i}{r_{1}}_{i}\leq w_{i}{r_{2}}_{i}+\epsilon)\ \land\ (\exists i.{r_{1}}_{i}<{r_{2}}_{i})$$

it is a relaxed version of Pareto dominance where the dominant tuple is allowed to be worse in some attributes up to an additive constant $\epsilon$. In fact, when we pick $\epsilon=0$, $\epsilon$-dominance reduces to Pareto dominance.

The $\epsilon$ skyline of a dataset for a preference vector $w$ and constant $\epsilon$ is simply the set of non-$\epsilon$-dominated tuples. Unlike traditional skylines, $\epsilon$-skylines are customizable in both preferences and output cardinality. Since $\epsilon$ is scaled with the weights $w_{i}$ while checking dominance, changing $w$ enables the operator to respond to the preferences of a user. The impact of $\epsilon$ on dominance decreases as the weight $w_{i}$ of an attribute increases.

Regarding the output cardinality, $\epsilon$-skylines do not provide a precise number but allow controlling the cardinality via changing $\epsilon$. For positive $\epsilon$, every tuple’s $\epsilon$-dominance region is larger than their Pareto dominance region, resulting in a smaller number of non-dominated tuples. Conversely, negative $\epsilon$ shrink the $\epsilon$-dominance regions and result in a larger number of non-dominated tuples. In fact, for datasets with traditional skylines that contain at least two tuples, $\epsilon=-1$ produces the whole dataset and $\epsilon=1$ produces the empty set[14].

The approaches described so far have focused on customizing the query somehow to include user preferences. Representative skylines [9][13] take an orthogonal approach, they reduce the cardinality of the skyline directly, by picking $k$ representative tuples from the skyline. The original implementation [9] picks the tuples that maximize the number of non-skyline tuples dominated by the picked tuples. A variant [13] of this implementation picks the tuples that minimize the maximum distance between a non-picked skyline tuple and any picked tuple.

Both versions have some drawbacks [13]. Consider the example in Figure 1, the skyline of the given dataset is $\{r_{1},r_{2},r_{4},r_{6},r_{8},r_{9}\}$. If we optimize the number of dominated non-skyline tuples and pick $k=3$, we get $\{r_{4},r_{6},r_{8}\}$. These two tuples are very similar in the trade-off they offer between attributes $a_{1}$ and $a_{2}$. This subset fails to represent the overall skyline since it does not include any other types of trade-off in the skyline and focuses on a small cluster of tuples. On the other hand, minimizing the maximum distance gives $\{r_{1},r_{4},r_{9}\}$. This selection presents other trade-offs much better, but it fails to capture that most of the tuples in the skyline have a trade-off similar To that of $r_{4}$.

Representative skylines have the benefit of requiring no user input. They provide a way to limit output cardinality, with different diversification techniques, without compromising the simplicity of skyline queries. On the other hand, since they admit no input other than the dataset itself, they are not customizable save for the output cardinality.

A query’s input is said to be flexible if it does not need to be precise and if small changes in the input do not cause significant changes in the output. Traditional skylines and representative skylines are the obvious superior choices for input flexibility since they have no input but the dataset itself. Thus, no additional parameter needs to be defined to make these queries. $\epsilon$-skylines are a bit less flexible, they require a value for $\epsilon$ and a weight vector but the weight vector does not affect the output as directly as it does in some other approaches. OSS operators, flexible skylines and UTK queries are somewhat less flexible because they require some specifics about either the estimate preference weights or the family of scoring functions. Finally, top-$k$ queries are easily the least flexible of the queries we consider, they require a precisely defined scoring function which affects the output dramatically.

A query is said to be customizable if it can adapt to the specific requirements of a user or a scenario. Traditional skylines are not customizable in any way, they simply return the same set of tuples for every scenario. Representative skylines, however, are mildly customizable since the output cardinality can be controlled. $\epsilon$-skylines, OSS skylines and UTK queries have noticeably higher customizability since they allow weight vectors to represent preferences over the attributes, though they only allow preferences to be expressed in the form of weighted sums. Top-$k$ queries and flexible skylines are fully customizable, they can be configured to return any tuple in the skyline.

The approaches are clearly divided into three groups on this property: Traditional skyline queries offer no control over the output cardinality. $\epsilon$ skylines and flexible skylines provide methods to increase or decrease the cardinality but offer no precise control. Lastly, top-$k$ queries, representative skylines, UTK queries and OSS operators have a parameter to specify the output cardinality.

Top-$k$ queries and representative skylines provide a ranking between the tuples they return. None of the other approaches have this property.