Gskyline query over data stream in wireless sensor network
 131 Downloads
Abstract
There are much data sampled continuously by sensors in the wireless sensor network. Storing and mining these data can find more potential information and provide help for decision making. As an important technology for data mining and multicriteria decision, skyline computation can identify the interesting single points for user. In order to analyze the groups of points, the groupbased skyline is proposed to query all the Pareto Optimal groups which are not gdominated by other groups with the same number of points. Existing algorithms about gskyline can just compute static data. However, data stream is very common in many applications, and it is very important to design algorithm go query gskyline over data stream. In this paper, we propose new algorithms to compute gskyline over a data stream. We present sharing strategy and then present two efficient algorithms: pointarriving algorithm and pointexpiring algorithm. The experimental results on three kinds of synthetic data and a real stock data show that our algorithms perform efficiently over a data stream .
Keywords
Wireless sensor network Groupbased skyline Data stream Sharing strategy1 Introduction
The Internet of things is the internetworking of physical devices, vehicles and other items embedded with different information sensors. These wireless sensors can collect much data from the terminals. The most importance is how to dig useful information from these mass data for special purpose.
As one of the important means of multidecision making, skyline query plays an important role in the applications of sensor network, data mining and so on. The skyline of a data set includes all the points which are not worse than any other points. Given a data set D with ddimension, every point q can be written as (q[1], q[2],…, q[d]) where q[i] is the ith attribute value of q. Assume that there are two points p = (p[1], p[2],…, p[d]) and q = (q[1], q[2],…, q[d]) in R^{d}, we say q dominates p, if q[j] ≤ p[j] for each j and there is at least one j(1 ≤ j ≤ d), q[j] < p[j]. The skyline of D consists of all the points which are not dominated by any other points in D. So the skyline query identifies all the best individual points.
However, the fire forces are limited and we cannot check each area at the same time, so if we intend to select 2 areas to examine, the traditional skyline query will not return the result directly. In order to solve such problem in a better way, the groupbased skyline query was proposed. The groupbased skyline (GSkyline for short) query is to identify the best groups not gdominated by any other groups with the same group size, and paper [1] proposed two algorithms for computing GSkyline. Different from the traditional skyline, the GSkyline presents much more useful information in more complexity phenomenons such as wireless sensor network, multidecision and data mining. In the above example, the GSkyline groups with 2 points include {p_{1}, p_{6}}, {p_{1}, p_{11}},{p_{6}, p_{11}},{p_{6}, p_{3}}, {p_{11}, p_{8}},{p_{11}, p_{10}}, then the fire force could consider selecting one group from the result.
With the groups set changing, the corresponding GSkyline maybe also change. For example, at first, the GSkyline groups are {p_{1}p_{3}, p_{2}p_{3}} because p_{1}p_{2} is dominated by p_{2}p_{3}, while p_{1}p_{3} and p_{2}p_{3} are not be gdominated by any other groups. When p_{4} arrives, the GSkyline groups are {p_{1}p_{3}, p_{1}p_{4}, p_{3}p_{4}, p_{2}p_{3}}, we can see that the new point arriving affect the GSkyline result. When p2 expires, the GSkyline changes to {p_{1}p_{3}, p_{1}p_{4}, p_{3}p_{4}}, the result shows the old point expiring affect the GSkyline too. So in order to keep the GSkyline effective all the time in the data stream, we should update the GSkyline when the new data arrives or an old data expires.
The naive method to find the GSkyline over a data stream is to use the existing algorithm PWise in paper [1] directly when the data set changes. However, the data maybe change quickly in the data stream, under this circumstance, repeating PWise computation for the whole data set will need much time cost and much redundant computation. Because when a new data arrives or an old data expires, some GSkyline groups may not change their status. For example, in Fig. 2, the groups p_{1}p_{3} and p_{2}p_{3} are GSkyline groups at the moment t and 2t. That is to say, in a data stream, when a point arrives or expires, we do not compute all the groups again. So the naive method is not a good idea.
In this paper, we present two algorithms to efficiently find GSkyline over a data stream in the wireless sensor network. The pointarrivingalgorithm can compute the new GSkyline when a new point arrives, and the pointexpirealgorithm will get the new GSkyline result while an old point expires. In order to improve this two algorithms effectively, we present some pruning theorems to remove the groups which will not affect the new GSkyline.

We present the problem of finding the GSkyline with k points over a data stream in the wireless sensor network. This query will provide much more useful information.

We present a sharing strategy to make us compute the new GSkyline based on the existing result. According to the pruning theorems, lots of groups will be pruned without computation.

We propose two algorithms to compute the new GSkyline over a data stream.

The experiments are performed based on three kinds of synthetic data and a real stock data.
Organization
The rest of this paper is organized as follows. In Sect. 2, we review the related work to our research work. In Sect. 3, we firstly give the definition and existing theorems of GSkyline, then we define the problem of GSkyline query over a data stream formally. Section 4 presents the two algorithms of GSkyline over a data stream, and gives relevant examples. In Sect. 5, we show the experimental results and evaluations of our algorithms. At last, we conclude our research work in this paper and propose the future work.
2 Related work
Since Borzsonyi et al proposed the skyline operator [2] in 2001, the skyline has been researched in many filed, and there are many algorithms of skyline have been proposed for different problems. Next, we describe the related work of skyline query.
BNL algorithm and D&C algorithm were proposed in paper [2]. BNL computed the skyline by scanning the whole data set and maintaining a candidate set, D&C returned the final skyline set by computing each subset skyline. In the algorithm SFS [3], the skyline was returned after all the data being sorted according to the monotone function. Bitmap [4] firstly mapped each tuple to a mbit vector, then got the skyline by computing the vectors, but this algorithm was only suitable for the static data set. NN [5] algorithm returned the skyline result by filtering the nearest neighbor points. BBS managed the data set by Rtree, and only the nodes containing result points would be visited.
In addition, there are some new skyline algorithms for the specific environment. The subspace skyline [6, 7, 8, 9] can compute the skyline by dividing the data set to some subspace. Kdominant skyline [10, 11] can return the points which are not kdominated by any other points, it can find much more potential information. Topk skyline [12, 13, 14, 15, 30] will find the points ranking in the top k position, this algorithm was only suitable for the query within a set limit in volume. In recent years, the skyline query on uncertain data has been studied, in this query, a threshold q was given at first, then the points whose probabilities are larger than q would be returned as probabilistic skyline [16, 17, 18]. [31, 32] introduced the MapReduce technology to compute the skyline efficiently. [19] firstly proposed the skyline query in a data stream, the data in the sliding window were managed in Rtree, and the skyline set was maintained by the interval tree. [20] presented algorithm LOOKOUT to compute skyline in a data stream. In paper [21], the data in the sliding window were managed based on a multilayer grid structure. [22] proposed a parallel algorithm for windowbased skyline targeting multicores.
Paper [23] returned the topk composition skyline, however, this paper did not propose the composition skyline formally. [24, 25, 26] defined and researched the group skyline query, they calculated the value of the same attribute of k points to form a group, then compared the dominance relation between the groups using the traditional dominance. The calculate functions commonly used in these work were some aggregate functions, such as, SUM, MAX, and MIN. [27] defined the group dominance concept based on uncertain data. In fact, which aggregate function should be used in practical application is difficult to select, so paper [1] proposed the Pareto optimal groups and groupbase skyline which can return all the Pareto optimal solutions. [28, 41] proposed efficient skyline group algorithms based on the algorithms in paper [24, 25] in a data stream, but the skyline group in their algorithms focus on some functions such as SUM, MAX and MIN, and the result of skyline groups under these functions is a subset of our Gskyline groups. The reason is that if group G is dominated by \( G^{{\prime }} \) according to Gskyline definition, this relation is right under SUM function, but the reverse is not true. So these algorithms are not suitable for our Gskyline groups. Paper [42] proposed the skyline algorithms over data stream, but they focus on individual subjects rather than groups. [33, 34, 35, 36, 37, 38, 39, 40] discussed different skyline applications in wireless sensor networks, such as continuous reverse skyline, spatial skyline, distributed dynamic skyline and probabilistic skyline query in the wireless sensor networks.
3 Preparations
In this section, we will present the foundation work, including the relevant definitions, basic theorems and the GSkyline algorithm in static data that will be used in our paper, then we propose our problem.
3.1 Definitions and theorems
Definition 1 (Skyline)
There are two different points p and q coming from the same data set D, we can say q dominates p, denoted by q \( \prec \) p, if q[j] ≤ p[j] for every j (1 ≤ j ≤ d) and at least one j, q[j] < p[j] (1 ≤ j ≤ d), where p[j] is the jth attribute value. The skyline consist of all the points which are not dominated by any other point in D.
Definition 2 (GDominante)
Given a data set D, there are two different groups G_{1} = {p_{1}, p_{2},…, p_{k}} and G_{2} = {\( p_{1}^{{\prime }} ,p_{2}^{{\prime }} , \ldots ,p_{k}^{{\prime }} \)}, where each point coming from D, we can say G_{1} gdominates G_{2}, if two arrays with k points for G_{1} and G_{2} are found, G_{1} = {p_{n1}, p_{n2},…, p_{nk}}and G_{2} = {\( p_{m1}^{{\prime }} ,p_{m2}^{{\prime }} , \ldots ,p_{mk}^{{\prime }} \)}, and p_{ni} ≤ p_{mi} for each i (1 ≤ i ≤ k) and at least one i, p_{ni} dominates p_{mi}.
Definition 3 (GSkyline)
The GSkyline consist of all the groups with k points which are not gdominated by any other group with the same size.
Example 1
The GSkyline is different from skyline, and it is also not same as skyline groups [24, 25, 26]. We take the data in Fig. 1 as an example. Let G_{1} = {p_{6}, p_{8}, p_{11}} and G_{2} = {p_{2}, p_{3}, p_{10}}, we can say G_{1} gdominates G_{2} because there are two arrays G_{1} = {p_{6}, p_{11}, p_{8}} and G_{2} = {p_{3}, p_{10}, p_{2}} such that p_{6} \( \prec \) p_{3}, p_{11} \( \prec \) p_{10}, and p_{8} \( \prec \) p_{2}. So G_{2} is not the GSkyline group, but G_{1} belongs to GSkyline because there is no other groups gdominates G_{1} with the same size.
Definition 4 (Skyline Layers)
The data set D can be divided to some layers, the layer_{i} is composed by skyline points of (D\( \bigcup\nolimits_{j = 1}^{i  1} {layer_{j} } \)), such as layer_{i} = skyline(D\( \bigcup\nolimits_{j = 1}^{i  1} {layer_{j} } \)) which is computed recursively until all the points of D are in layers, where layer_{1} is the traditional skyline of D.
Theorem 1
Given a data set D and the group size k, each point of GSkyline groups must be in the first k skyline layers.
Theorem 2
If there is a non GSkyline group G with k points, when another point from G’s tail set is added to it, this new group with k + 1 point also does not belong to the GSkyline.
Theorem 3
For each point p of a GSkyline group G, all of p’s parents must be in G too.
3.2 Algorithm in static data
 1.Skyline Layers. Firstly, all the points in D with 2dimension are sorted with increasing xcoordinate value, then all the points in this order are processed by binary search to compute which layer each point belongs to. Because the Pwise algorithm only compute the GSkyline for the given group size k, so just the first k skyline layers need to be constructed. The point with minimum ycoordinate in layer_{i} is referred as the tail point of layer_{i}. An example of skyline layers is shown in Fig. 3, and p_{11} is the tail point of layer_{1}.
 2.Construct Directed Skyline Graph (DSG). The DSG is a data structure which reflects the dominance relations between the first k layers. It is constructed based on skyline layers: all the points in D are calculated according to the increasing layers. For every point p, it should be compared with all the points in the previous layers and get their dominance relations, for the points which dominate p, p will be added to their children list, and these points will be added as p’s parents list. An example of DSG is shown in Fig. 4 based on the data in Fig. 1. In order to look clarity, all the indirect dominant relations are omitted, such as p_{11} \( \prec \) p_{2.}
 3.
Compute GSkyline. Based on the skyline layers and DSG, the algorithm performs by the classic set enumeration tree search framework. According to Theorem 2, the algorithm firstly prunes the nonGSkyline groups as soon as possible, because if a group is not the GSkyline group, it should not be expanded further, then according to Theorem 3, the algorithm prunes the point from the tail set of each node. Finally, the GSkyline is returned.
3.3 Our problem
The points in the static data set are stable, but the points in the data stream are dynamic, each point has its life cycle, and the point is only valid in its life cycle. Thus, the active data set of the data stream is not static, and it will change when a new point arrives or an old point expires. Aiming at this problem, we propose an algorithm to find GSkyline in the data stream. To the best of our knowledge, this problem is the first time to be considered here, and there has been no algorithm can solve it.
In this paper, we use sliding window to manage the data in the stream. There are two type sliding windows [29]: the one based on time, and another based on count. We focus on the timebased sliding window.
Definition 5 (Sliding Window)
For a time window W, and t is a random moment, when the point p arrives at t, its life cycle can be written as [t, t + W], and the point is only valid in this period, that is to say the point p is added to the active data set at t moment and is deleted from the active data set at t + W monent.
Theorem 4
Given a group G with k points coming from the dataset D, for each point p ∈ G, if all of its parents are in G, or it is the traditional skyline point of D, we can say G is GSkyline group.
Prove
Assume a group G = {p_{1}, p_{2},…, p_{k}}, each point in G and its parents are in G. If there is another group \( G^{{\prime }} \) = {q_{1}, q_{2},…, q_{k}} can gdominate G, we can find two permutations that for i∈[1, k], q_{i} \( \prec \) p_{i}, so q_{i} is p_{i}’s parent. From the known condition, we conclude that each q_{i} is in G, G and \( G^{{\prime }} \) have the same items. So there is not such a group which gdominates G, according to the concept of GSkyline, we can say G is a GSkyline group.□
4 Gskyline query over a data stream
In this section, we elaborate the algorithm to compute GSkyline in the data stream. For convenience, we maintain that: (1) the layer of point p, denoted by p._{l}, indicating which skyline layer the point p belongs to; (2) each point has the constant life cycle, denoted as [p.t_{arr}, p.t_{exp}], while p.t_{arr} means when the point p arrives and p.t_{exp} indicates when the point p expires, p.t_{exp} = p.t_{arr} + W.
In order to compute GSkyline effectively, we present the sharing strategy, and based on which we propose two algorithms to find GSkyline groups in the data stream.
4.1 Sharing strategy
When the point arrives or expires in a data stream, we can update the GSkyline based on the existing GSkyline.
Proof
The dynamic of the data stream reflects in two aspects: new point arriving and old point expiring. Here we take point p as an example. Both cases will result in the active data set changing, and the GSkyline of active data set will also change. But not all of the dominance relationships between the points are affected in these two cases, and only such relations are affected: the dominance relationships between p and its parents, and the dominance relationships between p and its children. According to Theorems 1 and 2, we find that when a new point p arrives, the nonGSkyline groups are still nonGSkyline groups, and the GSkyline groups not containing p’s children are still GSkyline groups, we should only check the other existing GSkyline groups and the new groups containing p. When an old point p expires, the existing GSkyline groups not containing p are still GSkyline groups, and the existing GSkyline groups containing p should be deleted, so we should check the status of some nonGSkyline groups.
That is to say, when the active data set changes, we do not have to computing all the active data, we can compute the new GSkyline based on the existing GSkyline.□
In the GSkyline processing over the data stream, this sharing strategy will prune most of groups which will not affect the new GSkyline, and help us to compute the GSkyline quickly in the data stream.
4.2 Computing Gskyline for point arriving
When a new point p arrives, we should firstly check which layer the point p belongs to, then we update the DSG to construct the new relationships between all the points, finally, we compute the GSkyline based on the sharing strategy. In order to compute the GSkyline continuously in the data stream, we should compute the skyline layers and the DSG for all the active points rather than the first k skyline layers and the DSG in the PWise [1].
Update the skyline layers
Example
Update the directed skyline graph (DSG)
When the new point p arrives, it changes the skyline layers, because the DSG is built based on the skyline layers, so we should also update the DSG of the active points.
According to the DSG concept, we know that when a new point p arrives, it does not affect other points except for its parents and children. So the DSG updating can be finished in two steps. Firstly, to find p’s parents, we can compare p with each point whose layer is smaller than p’s layer, if a point q is p’s parent, we should not compare p with q’s parents. Secondly, to find all of p’s children, we can compare p with each point whose layer is larger than p’s layer, if a point q is p’s child, we should not compare p with q’s children.
Example
Compute Gskyline for a point arriving
 1.
If p._{layer} > k. According to Theorem 1, the point of GSkyline groups must in the first k layers, so if p._{layer} > k, p will not affect the GSkyline result.
 2.
If p_{.layer} < k. In this case, p has no effect on the nonGSkyline groups and the GSkyline groups which do not contain all of p’s parents. However, the point p may only affect the GSkyline groups which containing all of p’s parents, here we denote these groups as candidate groups.
Prove
For the nonGSkyline groups G_{1}, there must be a group G_{2} dominating it, when p arrives, G_{2} still dominates G_{1}, so we can easily find p has no effect on such kind of groups.
For each GSkyline group (such as G_{3}) not containing all of p’s parents, according to Theorem 3, there must be no child of p existing in G_{3}, so there is no point dominated by p, and p has no effect on the GSkyline groups not containing all of p’s parents.
For the GSkyline groups not containing any parent of p, we can easily prove p has no effect on such kind of groups. Finally only the GSkyline groups containing all of p’s parents should be reevaluated.□
We call this kind of groups the candidate groups, and we divide the candidate groups into two kinds, and give the different solutions for them. If there is not any GSkyline group containing all of p’s parents, p will not affect the query result.
Solution 1
For each GSkyline group G which contains all parents of p except for p’s children, p will not affect its status. We can replace the leaf point of G by p to compose the new group which is GSkyline group, while this leaf point can not be p’s parent. However, G is still GSkyline group.
Prove
Assume G is a GSkyline group not containing p’s children, that is to say, there is not any point in G dominated by p, and there will be no group containing p can dominate G, so p does not affect G’s status, and G is still GSkyline group. On the other hand, if we replace the leaf point of G by p to compose the new group G’, we can not find another group which can dominate G’ because all of p’s parents are already in G, so G’ is GSkyline group too.□
Solution 2
For each GSkyline group containing p’s children, p will affect the its status. We replace the leaf point of G by p to compose the new group which will be GSkyline group. But, G is not GSkyline group yet.
Prove
If the GSkyline group contains p’s children, such as G = {g_{1}, g_{2},…, g_{i},…, g_{k}} and gi is p’s child, we can find \( G^{{\prime }} \) = {g_{1}, g_{2},…, p,…, g_{k}} can gDominates G because p \( \prec \) g_{i}, so the group G will not be GSkyline. At the same time, if we replace the leaf point of G by p to compose a new group \( G^{{\prime }} \), then each of the point in \( G^{{\prime }} \) and all of its parents are in the G, so according to concept of GSkyline and Theorem 4, we can see that there is no group which can gDominate \( G^{{\prime }} \), so \( G^{{\prime }} \) is GSkyline group.□
Example
4.3 Updating Gskyline for point expiring
Each point in the data stream has its life cycle, when an active point expires, the active data set will change too, so we should compute the new GSkyline groups of the new active dataset based on the existing result. In this section, we firstly update the skyline layers, then reconstruct the DSG, finally compute the GSkyline for point expiring.
Update the skyline layers
Example
Update the directed skyline graph (DSG)
When an old point expires, it may affect the existing skyline layers, and it maybe also change the DSG.
Example
Compute Gskyline for a point expiring
 1.
For the GSkyline groups
If G is a GSkyline group and does not contain p, according to GSkyline concept, there is not a groups \( G^{{\prime }} \)can Gdominate G, we can easily know that p’s expiration does not affect such groups.□
If G is a GSkyline groups and contains p, we can get the new kitem GSkyline group by deleting p from the old k + 1point GSkyline groups.
Prove From the algorithm for the static data set, we know that the GSkyline groups with k + 1 points come from GSkyline with k points. Assume that G = {q_{1}, q_{2},…, q_{k}, p} is GSkyline groups with k + 1 points, and it maybe contains p’s children, we know that each point in G and all of its parents are in G. When p expires and is deleted from G, \( G^{{\prime }} \) = G–p = {q_{1}, q_{2},…, q_{k}}, and each point in \( G^{{\prime }} \) and all of its parents are still in \( G^{{\prime }} \), according to Theorem 4, we can say \( G^{{\prime }} \) is GSkyline groups with k points when p expires.□
 2.
For the nonGSkyline groups
If G is a nonGSkyline group and contains p, it can be deleted safely.
Prove We can easily prove this conclusion because G will not exist when p expires.
If G is a nonGSkyline group and does not contain p, it maybe become GSkyline group when p expires.
Prove: When point p expires, it will not dominate its children any more, so some of nonGSkyline groups which does not contain p but contains p’s children maybe become GSkyline. According to Theorem 4, these groups must satisfy the condition: for such group G, each of point in G and all of its parents except p must be in G. Because p’s children’s parents contain p’s parents, so if we add p to G to form \( G^{{\prime }} \) with k + 1 points, \( G^{{\prime }} \) must be k + 1point GSkyline group of the active data set before p expires. Then we can get these candidate groups by deleting p from the k + 1item GSkyline groups, and these groups have been returned in (1). However, any other nonGSkyline groups which do not meet this condition will not belong to GSkyline, and they can be pruned safely.□
When a point p expires, we can quickly compute the new GSkyline groups based on the existing GSkyline groups. Based on the above strategy, our key idea of the algorithm is shown in Algorithm 4.
Example
5 Experiments
In this section, we present experimental evaluation about our algorithms.
5.1 Experiment preparation
For the correlated dataset and the anticorrelated dataset, the points are generated by selecting a plane perpendicular to the line from (0,…,0) to (1,…,1) using a normal distribution, while for the independent dataset, all attribute values of points are generated independently using a uniform distribution. For each type of data, we simulate the data stream in such way, a new point is generated randomly at regular intervals to simulate a new point arriving in the data stream, similarly, a point will be deleted at regular intervals to simulate an old point expiring in the data stream, and the point which generated earlier will be deleted earlier.
We also use the real stock data to evaluate the efficiency of our algorithms.
Because this is the first time to compute GSkyline over the data stream, our examine evaluation was conducted against the existing algorithm for static dataset. All the experiments are performed on a PC with 1.7 GHz Intel Core i7 processor running Windows 7 operation system with 8 GB memory and 1TB hard drive. The algorithms to be examined in the experiments are as follows.
PAA
Computing GSkyline groups for a new point arriving.
PEA
Computing GSkyline groups for an old point expiring.
PWise
PointWise algorithm of GSkyline for static dataset in paper [1].
5.2 Updating skyline layers
Firstly we examine our algorithms for updating skyline layers when the new point arrives or an old point expires. The PWise algorithm is to rebuild all the skyline layers by binary searching for the new active dataset, while our algorithm can update the skyline layers directly based on the existing skyline layers.
According to the distribution of each dataset, we find that the average layer number follows COR.ln > IND.ln > ANTICOR.ln. Then the running time of our algorithm shows little growth. Finally, our algorithms perform better than PWise.
5.3 Performance with respect to the synthetic data
In this section, we show the experimental evaluation of algorithms on the synthetic dataset. Each dataset is generated following the seminal work in paper [2].
5.4 Performance with respect to the real stock data
In order to evaluate the algorithms’ efficiency on a real data set, we do the experiments on the real stock data from www.finance.yahoo.com. The real data contain 3 *10^{5} records of stock, and each record has 3 attributes: change, volume and price.
6 Conclusions and future work
Processing dynamic data or data stream from the wireless sensor network will provide important information for users. In this paper, we proposed the problem of finding GSkyline groups over the data stream in the wireless sensor network. In order to compute the GSkyline groups efficiently, we firstly presented the sharing strategy, and then based on which, we proposed two algorithms PAA and PEA to compute the new GSkyline groups when a new point arrive or an old point expires. The experiment results based on the synthetic data and real data show our algorithms’ benefit. In the future, we will consider how to compute the GSkyline groups in wireless network if different sensors sample data at different time.
Notes
Acknowledgements
The authors will thank all the members in database laboratory of Donghua University. This work is supported by Natural Science Foundation of China (No. 61672151), Youth fund of Daqing Normal University (No. 15ZR07).
Compliance with ethical standards
Conflict of interest
The authors declare that there is no conflict of interest regarding the publication of this paper.
References
 1.Liu, J., Xiong, L., & Pei, J. (2015). Finding pareto optimal groups: Groupbased skyline. In VLDB (pp. 2086–2097).Google Scholar
 2.Borzsonyi, S., Kossmann, D., & Stocker, K. (2001). The skyline operator. In ICDE (pp. 421–430).Google Scholar
 3.Chomicki, J., Godfrey, P., & Gryz, J., et al. (2003). Skyline with presorting. In ICDE (pp. 717–719).Google Scholar
 4.Tan, K., Eng, P., & Ooi, B. (2001). Efficient progressive skyline computation. In VLDB (pp. 301–310).Google Scholar
 5.Kossmann, D., Ramsak, F., & Rost, S. (2002). Shooting stars in the sky an online algorithm for skyline queries. In VLDB (pp. 275–286).Google Scholar
 6.Pei, J, Jin, W., Ester, M., & Tao, Y. (2005). Catching the best views of skyline: Asemantic approach based on decisive subspaces. In VLDB (pp. 253–264).Google Scholar
 7.Lee, J., & Hwang, S. W. (2014). Toward efficient multidimensional subspace skyline computation. VLDB Journal, 23(1), 129–145.CrossRefGoogle Scholar
 8.Xia, T., & Zhang, D. (2006). Refreshing the sky: the compressed skycube with efficient support for frequent updates. In SIGMOD (pp. 491–502).Google Scholar
 9.Li, Y., Li, Z. Y., & Dong, M. X. (2015). Efficient subspace skyline query based on user preference using MapReduce. Ad Hoc Networks, 35, 105–115.CrossRefGoogle Scholar
 10.Chan, C. Y., Jagadish, H. V., & Tan, K. L. et al. (2006). Finding kdominant skylines in high dimensional space. In SIGMOD (pp. 503–514).Google Scholar
 11.Miao, X. Y., Gao, Y., et al. (2016). kdominant skyline queries on incomplete data. Information Sciences, 367, 990–1011.CrossRefGoogle Scholar
 12.Lee, J., You, G., & Hwang, S. (2008). Personalized topk skyline queries in highdimensional space. Information Systems, 1, 45.Google Scholar
 13.Jiang, T., Zhang, B., & Lin, D. (2015). Incremental evaluation of topk combinatorial metric skyline query. KnowledgeBased Systems, 74, 89–105.CrossRefGoogle Scholar
 14.Zhang, W., Lin, X., Zhang, Y., et al. (2010). Threshold based probabilistic top k dominating query[J]. The VLDB Journal, 19(2), 283–305.CrossRefGoogle Scholar
 15.Jiang, T., Zhang, B., Gao, Y., et al. (2013). Efficient top k query processing on mutual skyline. Journal of Computer Research and Development, 50(5), 986–997. (In Chinese).Google Scholar
 16.Le, T. M. N., Cao, J., & He, Z. (2016). Answering skyline queries on probabilistic data using the dominance of probabilistic tuples. Information Sciences, 340–341, 58–85.MathSciNetCrossRefGoogle Scholar
 17.Pei, J., Jiang, B., Lin, X., & Yuan, Y. (2007). Probabilistic skylines on uncertain data. In VLDB (pp. 15–26).Google Scholar
 18.Pujari, A. K., Kagita, V. R., & Garg, A. (2015). Efficient computation for probabilistic skyline over uncertain preferences. Information Sciences, 324, 146–162.MathSciNetCrossRefzbMATHGoogle Scholar
 19.Lin, X., Yuan, Y., Wang, W., & Lu, H. (2005). Stabbing the sky: Efficient skyline computation over sliding windows. In ICDE (pp. 502–513).Google Scholar
 20.Morse, M., Patel, J.M., & Grosky, W.I. (2007). Efficient continuous skyline computation. Information Sciences, 177(17), 3411–3437.MathSciNetCrossRefGoogle Scholar
 21.Li, H., Yoo, J. (2014). An efficient scheme for continuous skyline query processing over dynamic data set. In Proceedings of the international conference on big data and smart computing (pp. 54–59). Bangkok, Thailand.Google Scholar
 22.Tiziano, D. M., Salvatore, D. G., & Gabriele, M. (2015). A multicore parallelization of continuous skyline queries on data streams. LNCS, 9233, 402–413.Google Scholar
 23.Su, I.F., Chung, Y.C., & Lee, C. (2010). Topk combinatorial skyline queries. In Proceedings of the 15th international conference on database systems for advanced applications (DASFAA 2010). Google Scholar
 24.Im, H., & Park, S. (2011). Group skyline computation. Information Sciences, 188, 151–169.MathSciNetCrossRefzbMATHGoogle Scholar
 25.Li, C., Rajasekaran, S., Zhang, N., et al. (2014). On skyline groups. TKDE, 4(26), 942–956.Google Scholar
 26.Chung, Y.C., Su, I.F., & Lee, C. (2013). Efficient computation of combinatorial skyline queries. Information System, 38, 369–387.CrossRefGoogle Scholar
 27.Magnani, M., & Assent, I. (2013). From stars to galaxies: Skyline queries on aggregate data. In EDBT (pp. 477–488).Google Scholar
 28.Guo, Xi, Li, Hailing, Wulamu, Aziguli, et al. (2016). Efficient processing of skyline group queries over a data stream. Tsinghua Science and Technology, 21(1), 29–39.CrossRefzbMATHGoogle Scholar
 29.Babcock, B., Babu, S., & Datar, M., et al. (2002). Models and issues in data stream systems. In Proceedings of the ACM SIGACTSIGMOD symposium on principles of database systems. Wisconsin.Google Scholar
 30.Son, W., Stehn, F., & Knauer, C. (2017). Topk manhattan spatial skyline queries. Information Processing Letters, 123(1), 27–35.MathSciNetCrossRefzbMATHGoogle Scholar
 31.Lee, K. H., Kim, J., & Kim, M. H. (2017). Simultaneous processing of multiskyline queries with mapreduce. In IEICE transactions on information and systems (Vol. E100D, No. 7).Google Scholar
 32.Zaman, A., & Siddique, M. A. (2017). Annisa. Finding key persons on social media by using MapReduce skyline. International Journal of Networking and Computing, 7(1), 86–104.CrossRefGoogle Scholar
 33.Zhu, H., Zhu, P., & Li, X. (2017). Computing skyline groups: an experimental evaluation. In ACM turing celebration conferenceChina (p. 48).Google Scholar
 34.Zhu, H., Zhu, P., & Li, X. (2017). Parallelization of groupbased skyline computation for multicore processors. Concurrency and Computation Practice and Experience, 3, e4195.CrossRefGoogle Scholar
 35.Yin, B., Zhou, S., & Zhang, S. (2017). On efficient processing of continuous reverse skyline queries in wireless sensor networks. KSII Transactions on Internet and Information Systems, 11(4), 1931–1953.Google Scholar
 36.Wang, Y., Song, B., & Wang, J. (2016). Geometrybased distributed spatial skyline queries in wireless sensor networks. Sensors, 16(4), 454.CrossRefGoogle Scholar
 37.Ahmed, K., Nafi, N., & Gregory, M. (2016). Enhanced distributed dynamic skyline query for wireless sensor networks. Journal of Sensor and Actuator Networks, 5(1), 2.CrossRefGoogle Scholar
 38.Yin, B., Zhou, S., & Zhang, S. (2017). On efficient processing of continuous reverse skyline queries in wireless sensor networks. KSII Transactions on Internet and Information Systems, 11(4), 1931–1953.Google Scholar
 39.Wang, Y., Wei, W., & Deng, Q. (2016). An energyefficient skyline query for massively multidimensional sensing data. Sensors, 16(1), 83.CrossRefGoogle Scholar
 40.Example, F., & Quality, C. (2015). A environment. Alternative tuples based probabilistic skyline query processing in wireless sensor networks. Mathematical Problems in Engineering, 2015, 1–10.Google Scholar
 41.Wulamu, A., & Li, H., et al. (2016). Processing skyline groups on data streams. ubiquitous intelligence and computing and 2015. In 2015 IEEE 12th international conference on autonomic and trusted computing and 2015, IEEE 15th international conference on scalable computing and communications and its associated workshops (UICATCScalCom) (pp. 935–942).Google Scholar
 42.Nagendra, Mithila. (2014). Efficient processing of skyline queries on static data sources, data streams and incomplete datasets. Arizona: Arizona State University.Google Scholar
Copyright information
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.