2.1. Skyline Query

The Skyline Query is an important operation for many multiple-criteria decision-making applications that has received significant attention in the Database Community [18]. It is a popular and powerful paradigm that allows extracting points of interest from a multidimensional dataset [19].

Definition 1. Let q and p be two d-dimensional points defined as and , and without any loss of generality and assuming that the lowest values in each attribute are the best. The dominance relation is defined as:

Definition 2. Let D be a set of d-dimensional points. The Skyline is defined as:

Although the Skyline Query has been studied since the 1960s, it has been rediscovered in the context of databases recently. Borzsony et al. [5] propose an extension in SQL (Structured Query Language), to process the query and the first algorithms to solve this problem in databases. A series of algorithms have since emerged that respond to the Skyline Query in secondary memory. These algorithms can be classified in two main groups [19]:

• Sequential or generic algorithms: which do not require the input set to be indexed in any data structure. One algorithm is BNL [5], which searches the whole set, stores the points it considers that belong to the Skyline in a buffer, and updates the buffer as it searches through the points in secondary memory. Variants of this algorithm are SFS [20] and SaLSa [19,21], which preorder the set to reduce dominance comparisons.
• Algorithms based on indices or other structures: which require the input set to be indexed in some data structure to take advantage of its properties and reduce the number of dominance comparisons in advance. They use B-trees [22], Bitmaps [22], and R-trees [23].

In the second class of algorithms, the Branch and Bound Skyline algorithm (BBS) [2,24] is the most efficient strategy encountered in the literature. It presents a series of properties allowing the reduction of the search space, and is also suitable for working in interactive environments [1,23]. It runs through the nodes of an R-tree and avoids expanding nodes that do not contain Skyline points.

The BBS algorithm uses a minimal Heap H of MinDists. A minimal Heap (or MinHeap for short) is a binary tree in which every internal level is kept full and every key of each node is less or equal to the keys of its children. The key stored for the BBS algorithm is the MinDist, which is simply the minimal distance between the node and the origin. In the case of R-trees, the nodes are MBR (Minimal Bounding Rectangle), and the MinDist is calculated by the minimal distance of the rectangle to the origin, whose corresponding point is not necessarily a point of the R-tree and has to be further expanded. MinHeaps have an efficient (logarithmic in terms of its length) insertion and delete query times.

The following steps describe how the algorithm works:

1. The root of the structure (as R-tree) is expanded and its children are inserted in H.
2. The e entry on the top is extracted from H.
3. If e is dominated by some element of S, it is discarded.
4. If e is an internal node and is not discarded, it is expanded (consider as the i-th child of e). The dominance check of each node is performed in relation to S. If it is dominated, is discarded. If not, enters H.
5. If e is a point not dominated by any element of S, it is entered in S.
6. The algorithm ends when H is empty.

2.2. Skyline Query variants

A large number of variants of this query have emerged in the literature. Each variation is applicable and can solve different aspects of a problem. The BBS algorithm, in addition to its efficiency, can be adapted to easily respond to some of these variants without generating an excessive additional cost [2]. One variants is the Constrained Skyline Query.

Definition 3. Let D be a set of d-dimensional points and a hyper-rectangle within D. The Constrained Skyline Query asks for the set defined as: .

This variant delivers the Skyline points and dominates the points within a space defined by a series of restrictions, usually expressed as a hyper-rectangle [2]. For example, this query is useful when one of the dimensions is price and the query needs a minimum and/or maximum budget and/or when one of the dimensions is distance and it is possible to specify a distance range in the Skyline Query. This is how a new Skyline can be obtained based on the new restrictions and existing preferences. The BBS algorithm can be adapted to answer this variant by including the intersection between the e node and the range query as an additional condition in step 5 [2].

Another variant is Enumerating Skyline Query (or simply Enumerating Query).

Definition 4. Let D be a set of d-dimensional points and its Skyline points. The Enumerating Skyline Query asks for the set of pairs defined as:

This query returns the number of points dominated by s (called num(s)) for each point of the Skyline [2]. This information may be relevant in applications where the goodness of a point on the Skyline is determined by the number of dominated points [2]. To solve this variant, the conventional Skyline is calculated using BBS and then the number of points contained within the s dominance region is counted for each s point belonging to the Skyline.

2.3. k²-tree

The k²-tree compact data structure compactly stores binary sparse matrices [15]. It was originally shown in [16] to store Web graphs in an adjacency matrix. This structure is designed to compress large areas with zeros (no relation) [16] and improve clustered data compaction.

For binary relations, such as a Cartesian plane , the origin of the coordinate axis is located in the upper left corner of the matrix, while columns represent the x-axis and rows the y-axis starting at zero [15]. A point (i,j) in the Cartesian plane is then represented as a 1 in the (i,j) position in the adjacency matrix. If the points are on a different scale (or they are in ), they can be re-scaled to fit in a adjacency matrix, taking care of the level of precision needed.

Let M be a matrix with dimensions where n is a power of k. The matrix is subdivided into k² submatrices of . Submatrices are counted from left to right and from top to bottom. Each k² submatrix is represented by a bit whose value is 1 if it contains at least one point or 0 if it is empty. Submatrices with a value of 1 are recursively subdivided into k² submatrices. Subdivision ends when an empty submatrix is found or when the individual cells are reached. Fig 2 shows an example of using a k²-tree where k = 2 and n = 4.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 2. Example of a k²-tree.

In the upper left, the matrix representation of the points. In the upper right, its k²-tree representation. At the bottom, the k²-tree as bitmaps T and L.

https://doi.org/10.1371/journal.pone.0353358.g002

Any operation over a k²-tree requires two basic operations over the bitmaps T and L, which are typical of compact data structures. Let B be a bitmap of size l and the operation counts the number of bits of B whose value is b (zero or one) to position i with . In addition, the operation calculates the position of B to where there are i bits with value b [15,16].

The operation rank can be calculated in time O(1) and selected in time using storage n + o(n) [16]. Storage is used for both the bitmap and the additional structure that reduces the response time of both queries. Using these operations on the bitmaps, it is possible to efficiently pass through the k²-tree to obtain the children of a submatrix [16]. It is also possible to efficiently count points stored in a k²-tree in a given range r with an expected time of [25].

To our knowledge, there is no implementation of the Skyline Query on compact data structures. It is therefore needed to obtain all the points (uncompress the data) and apply a known algorithm in these non-indexed points.

We show that computing the Skyline Query over a k²-tree compact data structure can be done by significantly decreasing the number of dominance comparisons, thus reducing data processing and the amount of resources used in the Skyline Query. Initially, one can easily compare dominance at the bit level between sibling nodes and discard those dominated by any sibling. More than submatrices can be discarded.

3.1. Algorithm BBSkConstrained

Algorithm BBSkConstrained responds to the Constrained Skyline Query variant on indexed data in a k²-tree based on the BBS strategy. This is it uses a heap to store the submatrices data that contain points of the solution to revise later according to their distance to the origin. Information about the stored submatrices are the submatrix index i in the bitmap T, vertex (x, y) nearest to the submatrix origin (called MINDIST(i)), and submatrix size. It is important to point out that the MinDist of a submatrix (which is the distance between the upper left vertex of the square) is not necessarily the real minimal distance of the set of points inside the submatrix because the upper left vertex of the square could be empty. Each submatrix extracted from the heap is verified so that it is not dominated by any point already ahead in the Skyline. For each expanded submatrix, its k² children are revised in the same order in which they are located in the k²-tree. The search uses four discard conditions that determine whether the submatrix enters the heap (or the solution set if it is a leaf) or is discarded. The submatrix or leaf is discarded if one of the following occurs: (i) It is dominated by a Skyline point that has already been found. (ii) It is empty. (iii) It is dominated by some non-empty sibling. (iv) It is outside the range query.

The third discard condition can only be applied if the parent of the submatrix to be revised is completely contained within the range query. On the contrary, the sibling discarding the current submatrix could not have a Skyline point within the range query (i.e., the point that dominates the current submatrix could not be inside the range).

Algorithm 1. BBSkConstrained (k, r).

Input: K The k²-tree structure

Input: r The range query

Output: The Constrained Skyline Query answer

1: Insert root in heap

2: 

3: while do

4:   heap top

5:  if is not dominated by S then

6:   for each child in do

7:    if is not dominated by S then

8:     if then

9:      if is not dominated by its non-empty sibling then

10:       if is not a leaf then

11:        

12:       else

13:        

14:     else

15:      if then

16:       

17: return S

Algorithm 1 illustrates BBSkConstrained. Line 7 corresponds to the application of the first two discard conditions. Line 8 applies the precondition required for the third condition applied in the next line. This precondition checks that node is inside region r. Line 15 shows that the application of the fourth discard condition can be observed for those submatrices whose parents are not inside the range r.

Example 1. As an illustration, Fig 3 shows a set of points represented in a matrix (Fig 3(a)). Fig 3(b) is the level 1 of the k²-tree representation overlaying the points for k = 2. Fig 3(c) shows level 2 of the k²-tree representation overlaying the points. Fig 3(d) shows the leaf level of the k²-tree representation. Fig 4 shows the execution of Algorithm 1 considering the range query . In the graphics, the range query is depicted as a dashed square, the Skyline points are circled, the area dominated by the Skyline set is represented as a dotted polygon, and any point discarded by domination is marked with a × symbol. Additionally, every node processed in the current while loop iteration is highlighted. In the following paragraphs, we describe each iteration of the while loop in Algorithm 1.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 3. Example to run the algorithms.

(a) Points P represented in matrix form. (b) Level 1 of the k²-tree of P. (c) Level 2 of the k²-tree of P. (d) Leaf level of the k²-tree of P.

https://doi.org/10.1371/journal.pone.0353358.g003

Download:

• PNG
  larger image
• TIFF
  original image

Fig 4. BBSkConstrained running example.

(a) Checking the root matrix. (b) Checking the first non-empty child. (c) Finding the first point. (d) Pruning a dominated submatrix. (e) Discarding empty cells. (f) Discarding empty submatrices. (g) Pruning a dominated submatrix. (h) Finding a second point.

https://doi.org/10.1371/journal.pone.0353358.g004

At the beginning of Algorithm 1, the root node is inserted into the heap. During the first iteration of the while loop (Line 3), the first child at level 1 (upper-left node) is processed in the for loop (Line 6) (see Fig 4(a)). The condition in Line 7 does not apply yet because S is empty. Since this node is not completely contained within the range (Line 8) but intersects it, it is added to the heap. The same process applies to all other nodes at level 1 (see Fig 3(b)).

In the next iteration of the while loop, the first element in the heap is the upper-left node at level 1 (see Fig 4(b)). This node has only one non-empty child, , located at the bottom right, which is entirely within the range. The conditions in Lines 7 and 9 remain inapplicable because S is still empty, and has no siblings. Consequently, is added to the heap. At this point, the heap contains four elements: the upper-right, bottom-right, and bottom-left nodes from level 1, along with the recently added node from level 2. The latter has the smallest MINDIST() value and is therefore popped from the heap. Its first leaf, at position (2,2), is not discarded by any of the conditions in Lines 7, 8, or 9, as S is still empty. Since it has no siblings and lies within the range, it is added to the Skyline set in Line 13 as its first point (see Fig 4(c)). The second leaf of this node is discarded because it is dominated by the first Skyline point.

Now, the upper-right and bottom-left nodes at level 1 have the same MINDIST() value. First, consider the bottom-left node. It has three non-empty children, of which two intersect with the range and are added to the heap and the third child is discarded in Line 7 because it is dominated by the Skyline point (see Fig 4(d)).

In the next two iterations, all child nodes are discarded because they lie outside the range (see Fig 4(e) and Fig 4(f)).

The next node at the top of the heap is the bottom-right node at level 1, whose only non-empty child is dominated by S (see Fig 4(g)). Finally, the last node in the heap has one non-empty child within the range that is not dominated by S. This child is added to S (see Fig 4(h)). Once the heap becomes empty, the algorithm terminates, yielding the result S = (2,2), (1,7).

3.2 Algorithm BBSkConstrained: Theoretical analysis

The following lemma allows us to show that the Algorithm 1 is correct.

Lemma 1. Any point within a discarded submatrix cannot be a Skyline point for the range r.

Proof. A point is said to dominate an entire submatrix if every possible point is dominated by s, i.e., . It is important to note that the exact points within the submatrix are unknown while traversing the tree. Therefore, holds if the nearest possible point to the origin within (whether empty or not) is dominated by s; a condition that can be efficiently verified.

Similarly, if the farthest point to the origin in dominates the nearest point in . This condition ensures that must lie in the upper-left direction relative to . For instance, if is only above but not to the left of , then a point could exist such that . In this case, p₂ remains a potential Skyline point.

Finally, the second and fourth discard conditions follow directly from these observations. □

We now state the following theorem.

Theorem 1. Algorithm 1 is correct.

Proof. Let us to prove that every point added to S during the execution of the algorithm is a final skyline point. A point is added to the Skyline in Line 13. Suppose there exists a point p that dominates and satisfies and . In this case, must belong to a submatrix discarded by p or a submatrix containing p; thus, would never be added in Line 13. If and , or and , the point p must first be added to the Skyline set S because the order in which points are visited is determined by their distance from the origin. Consequently, would never be added in Line 13, as it would be discarded in Line 7.

Finally, every discarded point is not a Skyline point, as demonstrated in Lemma 1. □

Let the size of the matrix represented in the k²-tree be , the number of points be m = |P|, the number of children for each node be k², and the set S be the Skyline set. To estimate the theoretical resources used by Algorithm BBSkConstrained, we first need to determine the number of nodes entering the heap for specific actions in order to calculate the total number of nodes to be processed. To simplify the analysis, we consider the entire matrix as the range query. Therefore, the height of the tree is . However, a tighter upper bound can be derived if the range is smaller.

Since the structure is a tree, we only need to consider the following results: the lower height H (the height of the lowest node where the range is fully contained) and add the time to reach this range, expressed as .

The following lemma allows us to quantify the children inserted in the heap for each internal node.

Lemma 2. For each expanded node, at most of its k² children are inserted in the heap.

Proof. This is a geometric problem. Consider a grid of cells, where each cell represents a child of one node. The maximum number of cells (nodes) that are not dominated by any other corresponds to the cells along the upper-left perimeter, as any other cell has a greater value along at least one of the axes. This number is exactly cells, assuming that each node is non-empty.

An important question arises: how many nodes are expanded? At first glance, this question might seem impossible to answer directly. However, we can confidently state that if a node contains a Skyline point, it must be expanded until a leaf is reached, as such a node cannot be discarded.□

The following lemma allows us to quantify of amount of added nodes to the heap by level.

Lemma 3. When descending through a node i containing at least one Skyline point, and continuing until that point is reached, the heap grows by at most nodes, where is the height of the node.

Proof. When descending through the node to the first level, at most nodes are added, as stated in Lemma 2. For each subsequent lower level, the heap pops one node and pushes at most nodes. This results in a net addition of new nodes per level.

Therefore, the total number of nodes added to the heap is at most:

As a consequence of Lemma 3, we obtain the following theorem.□

Theorem 2. The maximum number of visited nodes is given by

where is the height of the highest node containing but not containing any with j < i.

On average, other expanded nodes do not descend much further because they are rapidly discarded by the previously computed Skyline points. This effect is particularly pronounced since the first Skyline point, s₁, is the closest to the origin.

We can state that , but the height of every other Skyline point depends on how clustered the points are in the space. If we suppose that, in the worst case scenario, , we obtain:

When points are more densely clustered, the average number of children expanded per node decreases because many of the potential children at higher levels are empty. Based on this observation, the best case scenario is: .

In a typical case for a k²-tree (commonly used for clustered data), most upper levels have empty nodes, with a higher density of points concentrated in the lower levels.

If we suppose that, for example, , we obtain:

When analyzing resource consumption over time, we must consider the cost of applying the four discard conditions. All conditions, except the first, have a computational cost of O(1). The first discard condition requires comparing the current node with all previously identified Skyline points, resulting in a worst-case cost of O(|S|). Additionally, each node must be inserted into and removed from the heap, which incurs a logarithmic cost relative to the heap size.

Therefore, the asymptotic time complexity of this algorithm ranges from

to

with an expected case of

For spatial storage costs, the heap is the most significant contributing structure. Thus, the spatial complexity ranges from to , with an expected case of

3.3. Algorithm SkylineX

We present a second alternative to the Constrained Skyline Query variant on indexed data in a k²-tree. It works in a way that is very similar to BBSkConstrained, except for two differences. The first is the order exhibited by the heap. Submatrices are ordered in relation to the smallest value in the x-coordinate of the node. If two submatrices have the same x-value, they are ordered in relation to the smallest y-coordinate.

The second difference is the union of the first and fourth discard conditions. Initially, we define rectangle R as equivalent to the range query r. Each time a Skyline point is located, R is updated by placing its lower left corner in the next upper right cell of the Skyline point that was found. The next Skyline point can only be found within R. Fig 5 provides an example of the R update while more Skyline points are found.

Algorithm 2. SkylineX(k, r).

Input: K The k²-tree structure

Input: r The range query

Output: The Constrained Skyline Query answer

1: Insert root in heap

2: 

3: R = r

4: while do

5:   heap top

6:  if then

7:   if is a leaf then

8:    

9:    Readjust R

10:   else

11:    for each child in n do

12:     if then

13:      if is not dominated by its non-empty sibling then

14:        

15: return S

Download:

• PNG
  larger image
• TIFF
  original image

Fig 5. Skyline X.

Update of R (highlighted) while more Skyline points are found. (a) R after the first Skyline point. (b) R after the second Skyline point.

https://doi.org/10.1371/journal.pone.0353358.g005

Algorithm 2 expresses the pseudocode of SkylineX. Before subdividing node , it is initially checked to see if it intersects R, as seen in Line 6 because this range could have changed while node was in the heap. Line 12 is the application of the second discard condition over child , which is checked again to see if intersects R. Line 13 is the application of the third discard condition after verifying the required precondition.

To explain the algorithm, we use the same input setting as in Example 1, and provide explanations for each iteration of the outer cycle (while) in Algorithm 2. Fig 6 illustrates the iterations. Again, the range query is depicted as a dashed square, R is the highlighted square, the points in the Skyline are circled, and a discard by domination is indicated by a × symbol. Finally, all nodes involved in the current while cycle are highlighted.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 6. SkylineX running example.

(a) Checking the root matrix. (b) Checking the first non-empty child. (c) Checking the second non-empty child. (d) Discarding empty cells. (e) Finding the first point. (f) Finding a second point.

https://doi.org/10.1371/journal.pone.0353358.g006

Example 2. At the beginning of Algorithm 2, the root is inserted into the heap, and its children are evaluated because it intersects with R and is not a leaf (see Fig 6(a)). Each of its children is non-empty and intersects with R (Line 12). However, since the root is not completely contained within the original range r, we cannot apply sibling-based discarding (Line 13). Therefore, all of its children are added to the heap.

In the next iteration of the while loop, the first element of the heap is again the upper-left node in level 1 (see Fig 6(b)). Its only non-empty child intersects with R (Line 12) and is fully contained within the original range r. It is not discarded by its siblings (Line 13) and is therefore added to the heap.

Then, we observe the first distinction from Algorithm 1. The top of the heap is now the bottom-left node in level 1, since the selection is determined by the distance along the x-axis (see Fig 6(c)). All its non-empty children intersect R, but since their parent is not fully contained within r, they are all added to the heap. However, the uppermost node has no children within R and therefore they are discarded (see Fig 6(d)).

The next leftmost element in the heap is the bottom-leftmost node in level 2. Its only non-empty child is not discarded by either Line 12 or Line 13. In the next iteration, this child is a leaf and becomes the first Skyline point, prompting an update of R (see Fig 6(e)).

Once again, the heap pops the leftmost node in the heap. Since there are two candidates, the uppermost node is selected (see Fig 6(f)). This node has two non-empty children, both of which are inside R and r, and are therefore added to the heap. In the subsequent cycle, the uppermost child of this node is popped first. As it is a leaf, it becomes the second Skyline point. With this update, R becomes empty, and the next element in the heap is discarded due to Line 6.

From this point onward, with R now empty, the remaining three nodes in the heap are discarded as they are popped, as dictated by Line 6, and the algorithm finished.

3.4. Algorithm SkylineX: Theoretical analysis

Since the first discard condition is replaced by the intersection with R, the cost of evaluating a node is always constant. Therefore, the computational cost is directly associated with the number of nodes to be processed. To reach a Skyline point, we must descend to a leaf; thus, we can use the result in Theorem 2 where the number of expanded nodes is given by:

where represents the height of the highest node containing but not containing for j < i.

We can affirm that , but because the first Skyline point is the leftmost point rather than the nearest to the origin, it is possible that more values are closer to the top of the tree. Based on these observations, the best- and worst-case scenarios with respect to the amount of expanded nodes remain the same as in the previous algorithm: from to .

However, the expected case differs from the previous one. As mentioned earlier, it is likely that a fraction of the Skyline points will have higher values compared to the previous algorithm, approaching the height of the tree. Consequently, the expected asymptotic behavior aligns with the worst-case scenario: .

Each node must enter and leave the heap, leading to a temporal cost that ranges from

to

For spatial cost analysis, the heap is the dominant factor. Thus, the spatial cost exhibits the same asymptotic behavior as the temporal cost. The best-case scenario is , while the expected and worst cases are .

Table 1 summarizes the algorithms’ logic and their time complexities.

Download:

• PNG
  larger image
• TIFF
  original image

Table 1. Time complexity of algorithms BBSkConstrained and SkylineX.

https://doi.org/10.1371/journal.pone.0353358.t001

4.1. Theoretical analysis

The temporal analysis of this algorithm is straightforward based on all the results that have already been calculated. Since every node is counted once, it is possible to obtain N in time . However, for each point , the algorithm still needs to identify the upper nodes dominated by s (Line 13). These nodes are called Maximal Quadrants in [25], which are the nodes completely inside the dominated area, while their parent is not. As reported in [25], a good average case for the number of maximal quadrants inside an area r is .

The best-case scenario for Algorithm 1 is . In this case, only the first Skyline points have a height equivalent to the tree height, and the rest are near the bottom. We can therefore assume that there is a constant number of count queries in the higher parts of the tree. Accordingly, r is O(n²), and the best-case scenario for Algorithm 3 is .

For the worst-case scenario, we consider Algorithm 1: . We assume a fraction of the Skyline points have a height in the higher part of the tree. In these cases, r is again O(n²), and we need to count almost every internal node, so the count is , with m the amount of points. Therefore, the worst-case scenario for Algorithm 3 is .

Similarly, the average case would need to count a fraction of the internal nodes with an asymptotic behavior of .

Table 2 summarizes the algorithm’s logic and its time complexity.

Download:

• PNG
  larger image
• TIFF
  original image

Table 2. Time complexity of algorithm Compact Enumerating.

https://doi.org/10.1371/journal.pone.0353358.t002

5.1. Skyline Query

Although the aim of this article is to contribute algorithms to evaluate the Constrained and Enumerating Skyline Query variants, the Skyline Query is evaluated in this section as a special case of the Constrained Skyline Query in which the range query is the matrix size. Synthetic data with uniform and clustered distributions were included in the evaluation. We consider two matrix sizes: and .

The algorithms in the charts are identified as BBSK Manhattan and BBSK Euclidean to refer to the BBSkConstrained (Algorithm 1) algorithm using the Manhattan distance and Euclidean distance, respectively, and SkylineX to refer to the SkylineX (Algorithm 2) algorithm.

Fig 9 shows the execution time of the algorithms compared with the number of points over datasets of different sizes with uniform and clustered distributions considering a matrix size of . There are no significant differences between BBSK Manhattan, BBSK Euclidean, and SkylineX in which the time used is approximately 100 .

Download:

• PNG
  larger image
• TIFF
  original image

Fig 9. Execution time Skyline Query.

Execution time (in ) over Skyline Query versus the number of points (the x-axis is on a logarithmic scale) considering a matrix size of . (a) Uniform data. (b) Clustered data.

https://doi.org/10.1371/journal.pone.0353358.g009

Fig 10 presents the execution times for a matrix of size . Under the uniform distribution, the BBSK Manhattan algorithm demonstrates the best performance, while the SkylineX algorithm exhibits the poorest performance, with a difference of approximately two orders of magnitude. This difference can be explained by the theoretical analysis, which shows that SkylineX is expected to operate near its worst-case scenario. Its performance improves only depending on the order and positions of the skyline points identified by the algorithm. In contrast, under a clustered data distribution, both BBSK Manhattan and SkylineX achieve similarly high performance, illustrating a favorable order and positioning of the skyline points.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 10. Execution time Skyline Query over a large matrix size.

Execution time (in ms) over Skyline Query versus the number of points (the x-axis is on a logarithmic scale) considering a matrix size of . (a) Uniform data. (b) Clustered data.

https://doi.org/10.1371/journal.pone.0353358.g010

Fig 11 shows the memory peak utilization of the algorithms compared with the number of points over different data distributions considering a matrix size of . As with execution time, there were no major differences in memory peaks between algorithms and between distributions; the maximum was approximately 65 KB, which is a very small amount of additional memory consumed by the algorithms.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 11. Memory peak of Skyline Query.

Memory peak (in KB) over Skyline Query versus the number of points (the x-axis is on a logarithmic scale) considering a matrix size of . (a) Uniform data. (b) Clustered data.

https://doi.org/10.1371/journal.pone.0353358.g011

Fig 12 illustrates the peak memory utilization of the algorithms in relation to the number of points across different data distributions, considering a matrix size of . In this case, no significant differences were observed among most of the algorithms. However, the BBSK Euclidean algorithm exhibits inferior performance, requiring approximately twice the amount of memory compared to the others.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 12. Memory peak of Skyline Query over a large matrix size.

Memory peak (in MB) over Skyline Query versus the number of points (the x-axis is on a logarithmic scale) considering a matrix size of . (a) Uniform data. (b) Clustered data.

https://doi.org/10.1371/journal.pone.0353358.g012

5.2. Constrained Skyline Query

The BBSkConstrained algorithms are evaluated in this section (Algorithm 1) and SkylineX (Algorithm 2). Eight different range query sizes were considered, namely 0.01%, 0.1%, 1%, 10%, 25%, 50%, 99%, and 100% of the matrix size. The ranges included sides that were parallel to the axes and located in the center of the matrix. The algorithms were described in the graphs as follows. For the BBSkConstrained algorithm, BBSK Constrained Manhattan allowed us to identify the variant that uses the Manhattan distance and BBSK Constrained Euclidean to identify the Euclidean distance. As for the SkylineX algorithm, Constrained X was used to identify it.

Uniform and clustered distributions were included in all the experiments with synthetic data. However, results were similar for both distributions; therefore only the results of the experiments over sets with uniform distribution are shown and discussed in this and the next sections. The results for this distribution are included because it is the least favorable for the k²-tree.

Fig 13 shows the resources used by the algorithms compared with the range query size. These experiments involved a matrix size of with 1M points or 1M cells in 1. For execution time (Fig 13(a)), the three algorithms exhibited a similar performance. Overall, as the range size increased, the performance of the three algorithms worsened, and the worst performance occurred with a 99% range. However, the best performance occurred with the 100% range, which is equivalent to what is illustrated in Fig 9(a). This is because the number of Maximal Quadrants to explore is reduced to 1, which is the complete matrix. Something similar occurs in the 25% range. In contrast, the 99% range resembles the worst-case scenario. The differences between the three algorithms were not significant for the memory peak (Fig 13(b)). The behavior of the execution time was repeated for the 99% and 100% ranges.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 13. Performance of Constrained Skyline Query.

Performance of Constrained Skyline Query versus range query size. (a) Execution time (in ). (b) Memory peak (in KB).

https://doi.org/10.1371/journal.pone.0353358.g013

Fig 14 shows the performance of the algorithms with a matrix size of , set size (number of points) of 0.1M, 0.5M, 1M, 5M, 10M, and 50M, and range size of 99% of the matrix size. From sets with a 5M size, BBSK Constrained Manhattan is approximately 1.4 times faster than SkylineX and requires less than 0.3 of the additional memory consumed by the latter.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 14. Performance of Constrained Skyline Query.

Performance of Constrained Skyline Query versus number of points (the x-axis is on a logarithmic scale). (a) Execution time (in ). (b) Memory peak (in KB).

https://doi.org/10.1371/journal.pone.0353358.g014

Fig 15 shows the resources used by the algorithms compared with the matrix size. These experiments consisted of 1M size sets, query range of , and a matrix size varying between , , , and . The three algorithms improved their execution time as the matrix size increased. In addition, BBSK Constrained Manhattan and BBSK Constrained Euclidean slightly outperformed Constrained X. Regarding the memory peak, Constrained X was affected by the matrix size and usually consumed slightly more memory than the other two algorithms.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 15. Performance of Constrained Skyline Query versus matrix size.

(a) Execution time (in ). (b) Memory peak (in KB).

https://doi.org/10.1371/journal.pone.0353358.g015

5.3. Enumerating Skyline Query

We compare our Compact Enumerating (Algorithm 3) algorithm with the following two algorithms. The first is Range Enumerating that is a solution for the Enumerating Skyline Query in which BBSkConstrained is used over the set of points to obtain Skyline points, and Range [27] is then used to count the dominated points. The second is Range Compact Enumerating that is a solution for the Enumerating Skyline Query in which BBSkConstrained is used over the set of points to obtain Skyline points, Compact Count [25] is then used to count the dominated points.

Fig 16 shows the resources used by the algorithms compared with the number of points. The experiments involved a matrix size of and set sizes of 0.1M, 0.5M, 1M, 5M, 10M, and 50M. For execution time, Range Enumerating was the algorithm that used the most time, on the order of seconds. For memory used, Compact Enumerating was the algorithm that consumed the most.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 16. Performance of enumerating Skyline Query.

Performance of Enumerating Skyline Query versus number of points (the x-axis is on a logarithmic scale) considering a matrix size of . (a) Execution time (in ms). (b) Memory peak (in KB).

https://doi.org/10.1371/journal.pone.0353358.g016

Fig 17 presents the resource consumption of the algorithms as a function of the number of points. The experiments were conducted on a matrix of size , with dataset sizes of 0.1M, 0.5M, 1M, 5M, 10M, and 50M points. Among the three algorithms, the Compact Enumerating algorithm achieves the best execution time, while the Range Enumerating algorithm shows the poorest performance, with a difference of at least two orders of magnitude. Regarding memory consumption, all algorithms demonstrate competitive behavior, with the Range Enumerating algorithm achieving the lowest memory usage.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 17. Performance of enumerating Skyline Query on a large matrix size.

Performance of Enumerating Skyline Query versus number of points (the x-axis is on a logarithmic scale) considering a matrix size of . (Execution time (in ms)). (b) Memory peak (in KB).

https://doi.org/10.1371/journal.pone.0353358.g017

Therefore, the most competitive algorithm of this analysis was Range Compact Enumerating, which had a good performance in terms of both time and memory. The behavior of Compact Enumerating is due to the arrangement used to maintain the relations or points counted in the visited submatrices.

5.4. Comparison between BBSkConstrained algorithm with the BBS on R-tree

In this section, we present experimental results comparing the performance of the BBSkConstrained algorithm with that of the BBS algorithm proposed in [28,29], which is based on the R-tree structure. We evaluate BBSkConstrained using the Manhattan distance metric, as it represents the best-performing variant of our approach. In contrast, BBS is implemented using the Euclidean distance metric, as this configuration yields its best performance.

The experiments were conducted on datasets ranging in size from 100,000–50,000,000 points in a two-dimensional space, defined over a domain of . To evaluate scenarios with higher densities in main memory for the R-tree, a smaller domain of was also considered, with point densities of 1%, 5%, and 10%. Both uniformly distributed and clustered datasets were included in the evaluation.

Each dataset was indexed using three structures: an adjacency list, a k²-tree, and an R-tree (including both index and data). Table 3 reports the storage requirements as a function of the number of points and the density. All reported values correspond to the average over ten datasets generated for each configuration.

Download:

• PNG
  larger image
• TIFF
  original image

Table 3. File Sizes (in KB) for Synthetic Data. Size ratio is the ratio between R-tree divided by k²-tree.

https://doi.org/10.1371/journal.pone.0353358.t003

As shown in Table 3, in terms of storage requirements, the R-tree requires between 9 and 14 times more space than our approach.

Table 4 presents the execution time of BBSkConstrained (using the Manhattan distance) compared with BBS (using the Euclidean distance) under two scenarios: (i) when the R-tree is fully stored in main memory, and (ii) when the R-tree resides in secondary memory. In scenario (i), the results strongly favor BBS, which outperforms our approach by a factor ranging from 32 to 113 in the case of uniformly distributed data, and from 11 to 43 for clustered distributions. In contrast, in scenario (ii), our approach significantly outperforms BBS, achieving improvements of up to five orders of magnitude.

Download:

• PNG
  larger image
• TIFF
  original image

Table 4. Execution times (in ms) comparing BBSkConstrained using the Manhattan distance and BBS based on the R-tree using the Euclidean distance, as a function of the number of points.

https://doi.org/10.1371/journal.pone.0353358.t004

Table 5 reports the execution time of BBSkConstrained (using the Manhattan distance) compared with BBS (using the Euclidean distance) under the same two scenarios as before: (i) when the R-tree is fully stored in main memory, and (ii) when the R-tree resides in secondary memory, now considering higher data densities. In scenario (i), execution times are comparable for both uniform and clustered distributions. This behavior is expected, as the running time of BBSkConstrained depends on the logarithm of the domain size and the size of the output, rather than directly on the number of points. Nevertheless, in scenario (ii), our approach continues to significantly outperform BBS, achieving improvements of up to five orders of magnitude.

Download:

• PNG
  larger image
• TIFF
  original image

Table 5. Execution times (in ms) comparing BBSkConstrained using the Manhattan distance and BBS based on the R-tree using the Euclidean distance, considering datasets with higher densities.

https://doi.org/10.1371/journal.pone.0353358.t005

These results are consistent with theoretical expectations. In scenario (i), the observed behavior is anticipated, as the higher computational cost of BBSkConstrained compared to BBS at lower densities can be attributed to the low arity of the k²-tree and the overhead associated with processing compressed data. In contrast, in scenario (ii), the higher execution time of BBS relative to BBSkConstrained is primarily due to the cost of I/O operations.

In summary, the experimental results indicate that our approach is well suited for deployment on devices with limited computational resources, particularly with respect to main memory usage. In contrast, the memory overhead required to maintain the entire R-tree in main memory is prohibitive.

5.5. Real datasets

Table 6 (Dataset Description) provides details of the datasets used in the experimentation. The second column indicates the number of points, relations, or cells in 1. The third column represents density, that is, the percentage of 1s compared with the total number of cells in the matrix, (1) is Range Enumerating, (2) corresponds to Range Compact Enumerating, and (3) is Compact Enumerating, v₁ and v₂ are acceleration metrics defined by and All the sets were stored in a k²-tree with a matrix size of .

According Table 6-(a) the Range Compact Enumerating and Compact Enumerating algorithms outperform the Range Enumerating algorithm when evaluating the Enumerating Skyline Query. Specifically, Range Compact Enumerating is on the average 543 times faster than Range Compact Enumerating and 417 times faster than Compact Enumerating.

Download:

• PNG
  larger image
• TIFF
  original image

Table 6. Results for Enumerating Skyline Query over real datasets. (a) Execution time (in ) and (b) Memory peak (in KB).

https://doi.org/10.1371/journal.pone.0353358.t006

Table 6-(b) indicates the memory peak of the Enumerating Skyline Query over the real datasets of (1) Range Enumerating, (2) Range Compact Enumerating, and (3) Compact Enumerating. Range Compact Enumerating is the proposal that uses the least additional memory, while Compact Enumerating requires the most memory. These results are consistent with the findings in Section 5.3 for synthetic datasets.

Fig 18 illustrates the resources used in the Constrained Skyline Query over real datasets. The range queries are 0.01%, 0.1%, 1%, 10%, 25%, 50%, 99%, and 100%. The ranges include sides that are parallel to the axes and located in the center of the matrix. The charts use the same labels as those in Section 5.2 to refer to the algorithms. As with the synthetic data, there were no significant differences between the algorithms. For time measurement, it is noteworthy that the peak for all algorithms occurred in the 0.1% range query, which was even higher than in the worst-case scenario for the 99% range. The memory peak also remained relatively constant for all algorithms, regardless of the range query.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 18. Performance of Constrained Skyline Query over real datasets.

Performance of Constrained Skyline Query over real datasets (the x-axis is on a logarithmic scale). (a) Execution time (in ). (b) Memory peak (in KB).

https://doi.org/10.1371/journal.pone.0353358.g018