An Edge-centric Ensemble Scheme for Queries Assignment

Abstract

The new era of the Internet of Things (IoT) reveals new potentials for the management of numerous devices. Such devices produce data streams that are guided to the Cloud for further processing. However, any processing in the Cloud, even if it is supported by increased computational resources, su ers from increased latency. For minimizing the latency, we can perform data processing at the edge of the network, i.e., at the edge nodes. The aim is to provide analytics and build knowledge on top of the collected data in the minimum time. In this paper, we deal with the problem of allocating queries, de ned for producing knowledge, to a number of edge nodes. The aim is to further reduce the latency by allocating queries to nodes that exhibit low load (the current and the estimated), thus, they can provide the nal response in the minimum time. However, before the allocation, we should decide the computational burden that a query will add. The allocation is concluded by the assistance of an ensemble similarity scheme responsible to deliver the complexity class for each query. The complexity class, thus, can be matched against the current load of every edge node. We discuss our scheme and through a large set of simulations and the adoption of benchmarking queries, we reveal the potentials of the proposed model supported by numerical results.

Keywords

• Edge nodes • Queries assignment • Ensemble similarity scheme

-

In the era of the Internet of Things (IoT), numerous devices form a vast infrastructure while being capable of performing simple processing tasks and exchange of data. One can identify a research challenge related to the connection of such devices with the network and three locations of data processing. Data can be processed at the devices, at the edge of the network (Edge/Fog) or at the Cloud. As we move to the upper layers of this architecture (from the devices to the Cloud), we observe improved computational resources, however, the latency increases as well. Current research e orts (e.g., [ 4 ], [ 10 ], [ 27 ]) focus on the data streams management at the edge to reduce the latency experienced by end users. Hence, the power of data processing and knowledge production is transferred to the edge nodes instead of relying on the Cloud or a central data warehouse.

A number of Edge Nodes (ENs) can be considered as the distributed repositories where queries can be executed to export meaningful analytics. ENs vary from simple routers to complete servers placed at various locations. ENs are connected with a number of devices and act as the repository of the data reported by them. ENs are responsible to execute the queries and report the result to the requested entity. The e cient management of the incoming queries as well as the provided responses will characterize the success of the supported applications. Usually, applications demand a response in the minimum time to provide high quality services to end users. The most important challenge is that ENs receive queries from multiple requestors and the collected data are quickly updated over time. This makes imperative the need for intelligent methods that will be able to manage the numerous requests (in the form of queries) and the large volumes of the collected data.

In this paper, we deal with the problem of query allocation to the appropriate ENs. Queries are reported through streams into a set of entities called Query Controllers (QCs). QCs are located at the Cloud and they have direct connection with multiple ENs. Our aim is to e ciently allocate every query to the appropriate EN in order to get the nal response in the minimum time. This is a multi-dimensional problem involving queries and ENs characteristics (e.g., query type, ENs location, ENs load, the collected data). In the current e ort, we focus on `matching' queries with ENs. We propose a method for classifying queries into a set of complexity classes that depict the burden that a query will cause to an EN. Hence, we can compare the requirements of the query with the ENs' load and decide if the speci c allocation is productive. A question arises: `Why do not we rely on the selection of ENs with the lowest load? '. The response is two-fold, i.e., (i) we want a mechanism to estimate the computational burden that a query will add to the selected ENs being di cult to classify a query in a speci c complexity class; (ii) we cannot be based on the current minimum load as ENs receive queries from multiple QCs, thus, the load is continuously updated. We propose models for both problems; an ensemble similarity scheme for the estimation of the complexity class based on historical queries and the decision related to the selection of ENs based on a `combined' view of their current and future loads. The following list reports on the contributions of our work: (i) we provide a modeling process for di erent types of queries; (ii) we provide an ensemble similarity scheme for concluding the complexity class; (iii) we provide a ENs selection model based on their current and the future load; (iv) we provide experimental evaluation of our ensemble similarity scheme.

The paper is organized as follows. Section 2 presents the related work while Section 3 discusses the problem under consideration. Section 4 presents the proposed ensemble similarity scheme and the adopted decision making technique. Section 5 reports on the experimental evaluation of our mechanism while Section 6 concludes our paper by giving insights in our future research directions.

Prior Work

In the IoT infrastructure, the collection of data in multiple locations is a common approach. Data are geospatialy distributed with multiple nodes hosting the data. The management of these numerous nodes is a very challenging task. A set of e orts try to reveal opportunities for the management of the distributed nodes/data. For instance, Dragon [ 19 ] tries to e ciently identify nodes that can reply to user requests based on static criteria describing nodes themselves or their data. In such settings, the important is to have a view on the nodes characteristics as well as the available data. However, IoT nodes exhibit di erent characteristics not only in the hardware but also in the software (e.g., their middleware). In [ 16 ], the authors propose a Distributed Data Service (DDS) providing functionalities for collecting and processing data. The main target is to enable multiple and distinct IoT middleware systems to share common data services, thus, to cover interoperability issues.

In any case, the execution of queries, in parallel, can increase the performance of the applications. This advantage is provided on top of the separation of data in a number of partitions. The separation of data may `emerge' as a natural consequence, e.g., when streams report data in high rates at various locations. Multiple e orts try to handle the problem of proposing algorithms for separating the available data. In [ 5 ], the authors adopt a sliding window approach. Streams are partitioned on the y taking into consideration the query semantics. A multi-route optimizer is proposed in [ 8 ]. The optimizer tries to exploit the intra- and inter-stream correlations to produce e ective partitions. The authors in [ 35 ] propose the separation of streams into a set of sub-streams over which query operators are executed in parallel. Another e ort that focuses on splitting functions is reported in [ 13 ]. The proposed partitioning functions are characterized by a set of properties, i.e, balance properties (e.g., memory, processing, communication balance), structural properties (e.g., compactness, fast lookup), and adaptation properties (e.g., fast computation, minimal migration).

In addition, various models, originated in the database community, have been proposed for delivering the similarity between SQL queries. Queries can be represented at the intentional [ 32 ] or at the extensional level [ 29 ]. Other techniques involve Information Retrieval (IR) models, i.e., queries can be depicted by vectors of features [ 2 ], a set of fragments [ 1 ] or graphs [ 31 ]. Example schemes deal with the inner product of vectors [ 29 ], the cosine distance [ 29 ] or the Jaccard coe cient [ 9 ]. Other more `sophisticated' solutions focus on the adoption of Support Vector Machines (SVMs) [ 33 ], [ 34 ]. SVMs aim to learn the ranking function applied on queries. This way, we are able to sort the queries and get the top-k of them. Most existing top-k query processing algorithms like [ 7 ], [ 17 ] assume that the ranking function is de ned over absolute attribute values or they are monotonic. The exploitation of the similarity can involve index structures (e.g., B-trees) to access the scoring of a sub-region. Other e orts e.g., [ 36 ], focus on relaxing the monotonicity assumption to include functions whose scores can be bounded in the given attribute value range.

In our past research, we also deal with the allocation of queries to a set of processors. In [ 20 ], we propose a time-optimized scheme for selecting the appropriate processor(s) through the use of the Odds algorithm. With the proposed model, we try to result the optimal allocation, in the minimum time. In [ 21 ], we present a Q-learning scheme to calculate the reward retrieved for an allocation. In [ 22 ], we extend the work presented in [ 21 ] and incorporate into the learning process a load balancer comparing it with a clustering model that creates groups of processors with similar characteristics. The missing contributions in our past research activities that we cover with the current work are: (i) in our previous models, we do not adopt any speci c similarity technique for `matching' queries with the available processors; (ii) Our past e orts do not deal with an ensemble scheme that identi es the complexity class of queries; (iii) our past models are mostly `static' meaning that they are applied on top of static values without taking into consideration the continuous update of processors characteristics; (iv) our previous research e orts require a training phase that increases the latency in the provision of the nal response especially when adopted in dynamic environments. 3

Problem De nition and High Level Description

Data Processing at the Edge of the Network. We consider a set of ENs, i.e., E N = en1; en2; : : : ; enjEN j placed at various locations (e.g., in a city or around the Globe). A set of IoT nodes (e.g., smartphones, sensors) are `connected' with every EN to send their data. ENs, on top of the collected data, can build and extend the produced contextual knowledge supporting decision making. A Query Processor (QP) is adopted in every EN to respond to any incoming query. Let the set of QPs be QP = qp1; qp2; : : : ; qpjEN j . QPs are `invoked' through the mediation of Cloud where a number of QCs are present. QCs receive queries, `invoke' the appropriate QPs, get their responses and return the nal result. We consider two types of applications, i.e., (i) applications that demand responses in real time; (ii) applications that do not de ne any time constraints. In our research, we focus on the former type.

In each EN, a dataset is formulated by the collected data de ning a geodistributed local data repository. Each dataset Di, present at the ith EN, stores multivariate data, i.e., vectors in the form x = hx1; x2; : : : ; xli where l is the number of dimensions. Dis are updated over time as streams produced by IoT devices report data at high rates. In our research, we cannot have any view on the data present in every dataset and we do not adopt any separation algorithm for the collected data.

In the upper layer (i.e., the Fog/Cloud), there is a number of QCs that have to process queries reported through streams Qi = fq1; q2; : : :g. QCs perform the selection of the appropriate ENs/QPs and the nal aggregation of the `partial' responses. As partial response, we de ne the response retrieved by an EN/QP that should be aggregated with the remaining results reported by other ENs/QPs. In our research, we provide models for the management of the ecosystem of QCs ENs/QPs (see Figure 1) and de ne techniques for the e cient allocation of the incoming queries. Our current e ort tries to `match': (a) queries q1; q2; : : : with; (b) the available QPs qp1; qp2; : : : ; qpjEN j.

Matching Queries and Processors. Every EN/QP exhibits speci c characteristics Cqp = fcq1p; cq2p; : : :g, e.g., Cqp = fload; speed; language; ef f ectivenessg. A detailed discussion on the QPs characteristics can be found in [ 25 ]. Some of them are: (i) the input language; (ii) the types of the performed optimizations; (iii) the optimization timing; (iv) the e ectiveness of processors as depicted by statistics; (v) the decision sites; (vi) the exploitation of the network topology; (vii) the exploitation of replicated fragments; (viii) the use of semi-joins. We propose to extend the aforementioned list and incorporate more `dynamic' characteristics that are related to high level features like the load and the speed of each QP. Such characteristics are delivered as a more detailed view of the performance depicting the current state of each QP. In our work, we focus on the load as an indication of their ability to quickly perform the execution of a query.

We consider that every QP maintains a queue where the incoming queries are placed and wait for processing. The size of the queue is adopted to deliver which represents the percentage of the maximum load that can be a orded by the corresponding QP. Without loss of generality, is de ned in [ 0,1 ] (a maximum queue size Qmax is adopted for such purposes). When ! 1 means that the corresponding QP exhibits a high load. The load is directly `connected' with the throughput of each QP and the velocity in which queries arrive in the discussed queue. A complex query (e.g., a join query - see below) may demand for more time and resources to be answered compared with a simple query (e.g., a select query). Usually, a complex query requires a high number of steps (a discussion on the query execution plans and the required steps can be found in the upcoming sections). The `classi cation' of the complexity of a query and its `combination' with the load of a QP is the main subject of the current work. Future extensions involve the modeling of more QPs' characteristics as well as a complex `matching' scheme for delivering the nal allocation.

Every query reported to a QC also has a set of characteristics depicted by Cq = fc1; cq2; : : :g, e.g., Cq = fclass; deadline; type; sizeg. According to [ 14 ], q `generic' characteristics are: (i) the type of the query (e.g., repetitive, ad-hoc); (ii) the query shape; (iii) the size of the query (e.g., simple, medium, complex). Based on Cq, speci c execution plans could be de ned in the form of a processing tree [ 14 ]. We propose to extend the aforementioned list and incorporate more characteristics that depict the complexity and the need for instant response. Such characteristics a ect queries' execution in terms of the resources required to produce the nal response. In the current work, we focus on the query class ; it depicts the complexity of a query. is aligned with the complexity performed by the operations required for producing the nal result. For instance, the operations required by a select query may be easier than the operations required by a Cartesian product. Various research e orts deal with the complexity of queries [ 3 ], [ 28 ], [ 30 ].

Delivering the Query Complexity Class. Our aim is to combine with and support the decision if a query can be e ciently executed in a QP. Initially, we have to assign the incoming query to a complexity class (i.e., a typical classi cation task). However, it is di cult to `match' any query against a single class due to the increased number of constraints that could be adopted in each query statement. The nal complexity should be de ned based not only on quantitative (e.g., number of constraints / conditions) but also on qualitative (e.g., type of operations / constraints) characteristics. For handling this complicated process, we propose a `fuzzy' approach and de ne a Fuzzy Classi cation Process (FCP). The FCP is the process of grouping individuals having the same characteristics into the same fuzzy set based on a membership function that indicates whether a query is a member of a class. The FCP tells us the membership of a query in each of the pre-de ned classes, thus, we could be able to estimate the computational burden that will be added to the selected QP. A dataset of historical queries (i.e., a set of tuples) together with their corresponding classes is available for the FCP. The same class may be involved in multiple tuples, thus, in multiple queries. The queries dataset if de ned by database experts and its creation is not the focus of the current work.

For evaluating for qj , we adopt Information Retrieval (IR) and Data Mining (DM) techniques. We prefer to adopt fast similarity techniques to deliver the nal result in real time instead of adopting a classi cation approach that requires a training phase. Our model can be easily executed, even if the queries dataset is updated; this is not the case in the majority of the classi cation algorithms (the training phase should be executed again). The set = 1; 2; : : : ; j j depicts the pre-de ned classes where a query can/should be classi ed. Let the queries dataset be QD with tuples in the form hsk; ki ; 8k 2 f1; 2; : : : ; jQDjg. sk represents the query's statement and k 2 . An example query statement could be fSelect price from stocks where id =0 RBS0g. The function f gets the qj and based on QD delivers a vector that depicts the `similarity' of qj with every class in , i.e., f (qj ; QD) ! qs 2 Rj j. qs contains values in [ 0,1 ] forming the basis of our FCP. An example vector could be qs = h0:2; 0:8; 0:3i for = 1 = O(nlogn); 2 = O(n); 3 = O(n2 . qs shows that the qj `belongs' by 20% to the rst complexity class, by 80% to the second and by 30% to the third. Based on qs, we can estimate and match it with QPs characteristics (i.e., in this e ort).

For calculating qs, we can be based on various e orts that deliver the similarity between queries. The interested reader can refer in [ 23 ] for more details. We propose the use of an ensemble scheme for evaluating the nal similarity between qj and every tuple hsk; ki in QD. The ensemble model aims at avoiding the disadvantages of each individual metric. We process all the available tuples in QD classi ed to k. The ensemble scheme adopts the set E = e1; e2; : : : ; ejEj of similarity metrics. For instance, E could involve the Hamming distance [ 26 ], the Jaccard coe cient [ 1 ], the Cosine similarity [ 26 ] or any other metric. Any distance metric available in the corresponding literature could be transformed to depict the similarity between qj and hsk; ki. For instance, if ed is the Euclidean distance between qj and a tuple, their similarity can be calculated by 1+1ed . 4

Allocating Queries to Processors

The Ensemble Scheme. The adopted similarity metrics are applied on each tuple classi ed to k aggregated to a successive step for the nalization of qks, i.e., the nal similarity of qj with k. Formally the `2D aggregation' is calculated as follows: qks = (! fei(qj ; hsk; ki)g ; 8i, 8 hsk; ki. ! realizes the envisioned ensemble similarity scheme while the aggregation operator produces the qks through multiple ! values.

For !, we consider that every single result (i.e., ei(qj ; hsk; ki) represents the membership of qj to a `virtual' fuzzy set. We have jE j membership degrees that should be combined to get the nal similarity for the each tuple. For instance, if we get e1 = 0:2, e2 = 0:5 and e3 = 0:3, qj `belongs' to the e1 fuzzy set by 0.2, to the e2 by 0.5 and to the e3 by 0.3. ! is a fuzzy aggregation operator, a jE j-place function ! : [0; 1]jEj ! [0; 1]) that takes into consideration the membership to every fuzzy set and returns the nal value. Aggregation operators are well studied in various e orts [ 12 ], [ 15 ]. Through a high number of experiments [ 12 ], [ 15 ], a number of aggregators are identi ed to exhibit the best performance, i.e., the Einstein product, the algebric product, the Hamacher product [ 15 ] and the Schweizer-Sklar metric [ 12 ].

In the proposed model, we adopt the Hamacher product as it gives us more opportunities to `tune' the result through the parameter 0. The nal ! for a e_ e tuple is de ned as: !i = a+(1 a)(e_+e e_ e) where e_ and e are two similarity values. As those values may be distributed in [ 0,1 ], i.e., similarity metrics may `disagree', we propose the use of the top-n similarity values based on their signi cance level. The Signi cance Level (SL) depicts if a value is `representative' for many other results. We borrow the idea from the density based clustering where the centroids are points being connected with many other objects. We propose the use of the radius and calculate the SL for each similarity result as follows: SLei = j 2) ; 8j, where 1 and 2 are parameters adopted to 1 1+e ( 1jd(ei;ej) smooth the sigmoid function. With the sigmoid function, we want to eliminate the SL of values with a low number of `neighbors' in the radius . Finally, the results are sorted in descending order of the SL and the top-n of them are processed with the Hamacher product to deliver the nal aggregated similarity value.

The operator builds on top of the ! values produced for each tuple in QD classi ed in k. Let !1; !2; : : : ; !m are those values. For their aggregation, we rely on a Quasi-Arithmetic mean, i.e., qks = m1 Pim=1 !i 1 where is a parameter that `tunes' the function. When = 1, the function is the arithmetic mean, when = 2, it is the quadratic mean and so on. After calculating the nal values for each k, we get qs = 1; 2; : : : ; j j .

The Matching Process. The next step is to estimate the required processing steps to conclude the response for the qj , thus, to identify its computational burden. We consider an additional vector Ts = T1; T2; : : : ; Tj j which represents a `typical' number of processing steps (an upper bound) for each class. The expected number of processing steps for qj is de ned by TE = Pji=j1 iTi. Recall that depicts the current load of a processor, thus, 1 depicts the room for `hosting' additional queries. The most common execution approach is the creation of an execution tree where the required steps are connected 1. A statistical study for the average required steps T E in various query execution plans can assist us to de ne the room for additional queries in QPs. TE should be compared with T^E = (1 ) T E to identify if qj can be executed in the speci c QP. When TE T^E , we assign a reward r1 to the speci c QP, otherwise, r1 corresponds to a penalty.

In addition, we want to incorporate in the decision process, our view on the future load of QPs. Hence, we maintain historical values and apply a single linear estimator to identify the future load as in [ 22 ]. The idea is to see if the current (through T^E ) and future load can support the execution of qj . For the latest W observations t 1; t 2; : : : ; t W , we estimate the future load ^ through the linear combination of t k; k = 1; 2; : : : ; W with real-valued ak coe cients. The set fakg is estimated to minimize the error between ^ and . In our e ort, we adopt the Levinson-Durbin algorithm [ 24 ], [ 11 ]. Based on ^, if TE 1

^ T E , we assign a reward equal to r2 to the speci c processor, otherwise, r2 corresponds to a penalty.

The ith QP gets a reward/penalty equal to ri = PjjR=j1 sgn(ri)ri where jRj is the number of rewards and sgn(ri) is the positive sign if the ri deals with a reward; otherwise, it is the negative sign. For each QP, we calculate the probability of allocation pi delivered by the softmax function [ 6 ], i.e., pi = PjiE=eN1rij eri . qj is allocated in the processors that their probability exceeds a pre-de ned threshold pT . This secures the optimal allocation based on the Probability Ranking Principle [ 18 ], i.e., if QPs are ordered by decreasing pi, then the model's e ectiveness is the best to be gotten for the qj . 1 https://docs.oracle.com/database/121/TGSQL/tgsql sqlproc.htm#TGSQL186

Experimental Evaluation

Experimentation Setup. We report on the performance of the proposed scheme through a large set of simulations. Our simulator is written in Java and manages a number of queries retrieved by a real dataset. We rely on two benchmarking datasets, i.e., TPC-DS and TPC-H (http://www.tpc.org/). TPC-DS is the defacto industry standard benchmark for measuring the performance of decision support solutions. The TPC-H is a decision support benchmark that consists of a suite of business oriented ad-hoc queries. For each of the adopted queries, we de ne its class as described in [ 30 ] where a survey of databases experts de ne their view on the complexity of every query. We classify our evaluation queries in six (6) classes.

We adopt three (3) performance metrics: (i) the time required for concluding a query allocation depicted by measured in seconds. The lower the is the more e cient the model becomes; (ii) the di erence between of the rst selected QP compared to the lowest observed in the group of QPs . ! 0 means that the proposed model selects the best possible QP; (iii) the di erence of between the lowest value in the group and the average of the top-n selected QPs . We want close to zero which means that the proposed model selects the best possible QPs. and depict the correct matching between the qj and the available QPs. When we meet `ties', i.e., QPs with the same pi, we experiment with two scenarios: Scenario A. the random selection of the QPs for the nal allocation; Scenario B. the selection of the lowest possible . In the later case, there is the risk of possible bottlenecks (consider the scenario where all the QCs select QPs with the lowest load when `ties' arise).

We get jE N j 2 f10; 100; 1000; 10000g and consider following: (a) the Uniform; (b) the Gaussian distributions. With the Uniform distribution, we simulate a very dynamic environment where continuously changes. The Gaussian distribution assumes a `smooth' environment where abrupt changes in are absent. In each simulation, we randomly select a query and apply the proposed model. The adopted parameters are as follows: = 0:1, 1 = 5:0, 2 = 7:0, a = 1:5, = 10:0, W = 20:0, r1 = r2 = 10:0.

Performance Assessment. Initially, we report on the complexity of the proposed scheme which depends on: (i) the complexity of the ensemble similarity model; (ii) the complexity of the QPs selection process. The rst complexity is a ected by the j j and the jQDj (the size of the dataset). Hence, the complexity for (i) is O(j )j jQDj. In addition, when we produce the similarity values with every metric in E , we require O(jE j2 + m) to calculate the value. O(jE j2) is required to produce the SL for each metric and, additionally, O(m) to produce the . Hence, the nal complexity of our scheme is O j j jQDj jE j2 + m . In Figure 2, we plot the complexity of our scheme. At the left, we observe that a combination of a high number of training queries with a high number of j j increases the computational time. At the right, we see that the number of similarity metrics does not mainly a ect the complexity. However, when remains low (e.g., below 20), the required time for concluding an allocation is low as well. 1048 3 2 1 0 4000 1088 6 4 2 0 100 2000 0 0 50 100 50

In Table 5, we present the conclusion time for various numbers of QPs ( metric). The distribution of does not a ect the result; The adoption of the Uniform mainly results lower conclusion time than the Gaussian distribution. In any case, our results are below 0.3 seconds no matter the jE N j. This depicts the e ciency of our model and its ability to support real time decisions.

In Figure 3, we depict our results for the metric. We observe that, as natural, the Scenario A leads to a higher di erence with the lowest than the Scenario B. The random selection of a QP, in the case of ties, does not secure the optimality of the selection but it focuses only in the `load balancing' aspect of the problem. We also observe that the di erence is high as jE N j ! 10; 000, The higher the jE N j is, the higher the di erence becomes. These results stand for the Scenario A. In the Scenario B, we see that the increased jE N j positively a ects the performance as approaches zero. In the Scenario B, our model relies on the minimum , however, under the risk of bottlenecks if this decision is adopted by the majority of the QCs.

In Figure 4, we present our results for the metric. Now, the di erence is higher than in the case. The reason is that the remaining selected QPs in the top-n list and their load negatively a ect the statistics. In any case, the load of the selected QPs remains low in Scenario B. 6

Conclusions and Future Work

The e cient management of queries adopted to provide analytics comes, more intensively, into scene in the IoT era. Queries should be immediately and e ciently

metric. responded to support high quality services. In this paper, we discuss a setting where queries are set into the Cloud and responded in multiple edge nodes. We propose a model for depicting the complexity of a query and an allocation process to the edge nodes. The complexity class de nes the computational burden that a query imposes to a node and it is delivered by an ensemble similarity scheme. Our model does not impose any training process and does not require an increased time to deliver the nal result. Our evaluation process reveals the pros of the model and through numerical results con rms the increased performance. Our future research plans involve the incorporation of more parameters into the decision making process. For instance, we can take into consideration the deadline de ned for the nal execution of a query or the statistics of data hosted in each edge node. This way, we will be capable of providing a mechanism fully adapted to the queries and nodes characteristics together with the requirements de ned by end users.

Acknowledgment

This work is funded by the EU/H2020 Marie Sklodowska-Curie (MSCA-2016) under the INNOVATE project; Grant#745829.

References

1. Aligon , J. , et al., ' Mining preferences from OLAP query logs for proactive personalization' , in Proc. of ADBIS , 2011 .

2. Antara , G. , et al., 'Plan selection based on query clustering' , in Proc. of VLDB Endowment , 2002 .

3. Artail , H. , et al., 'SQL query space and time complexity estimation for multidimensional queries' , Int. Journal of Int. Inf. and Database Systems , 2 ( 4 ), 2008 , pp. 460 { 480 .

4. Aujla , G. S. , et al., 'Optimal Decision Making for Big Data Processing at EdgeCloud Environment: An SDN Perspective' , IEEE TII , vol. 14 ( 2 ), 2018 , pp. 778 { 789 .

5. Balkensen , C. , Tatbul , N. , ' Scalable Data Partitioning Techniques for Parallel Sliding Window Processing over Data Streams' , in Proc. of 8th Int. Workshop on Data Management for Sensor Networks , 2011 .

6. Bishop , C. , ' Pattern Recognition and Machine Learning' , Springer, 2006 .

7. Bruno , N. , Gravano , L. , Marian , A. , ' Evaluating top -k queries over web-accessible databases' , In ICDE , 2002 .

8. Cao , L. , Rundensteiner , E. A. , 'High Performance Stream Query Processing with Correlation-Aware Partitioning' , VLDB Endowment , 7 ( 4 ), 2013 , pp. 265 { 276 .

9. Chatzopoulou , G. , et al., ' The QueRIE system for personalized query recommendations', IEEE Data Eng . Bull., 34 ( 2 ), 2011 , pp. 55 - 60 .

10. Dias , M. , et al., ' Distributed Data Stream Processing and Edge Computing: A Survey on Resource Elasticity and Future Directions' , NCA, 103 , 2018 , pp. 1 { 17 .

11. Durbin , J., ' The tting of time series models' , Rev. Inst. Int. Stat. , vol. 28 , 1960 , pp. 233 - 243 .

12. Farahbod , F. , Eftekhari , N. , ' Comparison of Di erent T-Norm Operators in Classi cation Problems' , IJFLS, vol. 2 ( 3 ), 2012 .

13. Gedik , B. , ' Partitioning Functions for Stateful Data Parallelism in Stream Processing' , VLDB Journal , vol. 23 ( 4 ), 2014 , pp. 517 { 539 .

14. Hameurlain , A. , Morvan , F. , ' Evolution of Query Optimization Methods' , TLSDK-CS, 2009 , pp. 211 { 242 .

15. Hossain , K. , Raihan , Z. , Hashem , M. , ' On Appropriate Selection of Fuzzy Aggregation Operators in Medical Decision Support System' , In Proc. of the 8th Int. Conf. on Comp. and Inf. Technology , 2005 .

16. Huacarpuma , R. C., at el., ' Distributed Data Service for Data Management in Internet of Things Middleware' , Sensors , vol. 17 , 2017 .

17. Hwang , S. , Chang , K. , ' Optimizing access cost for top-k queries over web sources: A uni ed cost-based approach' , in ICDE , 2005 .

18. Jones , S. , et al., 'A probabilistic model of information retrieval: development and comparative experiments' , Inf. Processing and Management , 36 ( 6 ), 2000 , pp. 779 { 808 .

19. Kolcun , R. , McCann , J. A. , ' Dragon: Data Discovery and Collection Architecture for Distributed IoT' , Int. Conf. on IoT , 2014 .

20. Kolomvatsos , K. , 'An Intelligent Scheme for Assigning Queries' , Springer Applied Intelligence, doi. org/10.1007/s10489-017-1099-5 , 2018 .

21. Kolomvatsos , K. , Hadjiefthymiades , S. , ' Learning the Engagement of Query Processors for Intelligent Analytics' , Applied Intelligence Journal , vol. 46 ( 1 ), 96 - 112 , 2017 , pp. 1 { 17 .

22. Kolomvatsos , K. , Anagnostopoulos , C. , ' Reinforcement Machine Learning for Predictive Analytics in Smart Cities' , Informatics, 4 ( 16 ), 2017 .

23. Kul , G. , et al., 'Similarity Measures for SQL Query Clustering' , IEEE TKDE , 2018 .

24. Levinson , N., ' The Wiener RMS error criterion in lter design and prediction' , Journal of Math. Phys. , vol. 25 , 1947 , pp. 261 - 278 .

25. Ozgu , M. T. , Valduriez , P. , 'Overview of Query Processing', Principles of Distributes Database Systems , 2011 , pp. 205 { 220 .

26. Pandit , S. , Gupta , S. , ' A Comparative Study on Distance Measuring Approaches for Clustering' , Int. Journal of Research in Computer Science , 2 ( 1 ), 2011 , pp. 29 { 31 .

27. Satoh , I. , ' Edge Data Processing' , in Proc. of the 30th WAINA , 2016 .

28. Simon , M. , Pataki , N. , 'SQL Code Complexity Analysis' , Proc. of the 8th Int. Conf. of Applied Informatics , 2010 .

29. Stefanidis , K. , Drosou , M. , Pitoura , E. , ' You may also like results in relational databases' , in Proc. of PersDB , 2009 .

30. Vashistha , A. , Jain , S. , ' Measuring Query Complexity in SQLShare Workload' , Proc. of the Int. Conf. on Management of Data , 2016 .

31. Yang , X. , Procopiuc , C. M. , Srivastava , D. , ' Recommending join queries via query log analysis' , in IEEE ICDE , 2009 .

32. Yao , Q. , An , A. , Huang , X. , ' Finding and analyzing database user sessions' , in Proc. DASFAA , 2005 .

33. Yu , H. , et al., ' Exact indexing for support vector machines' , in proc. of the 2011 ACM SIGMOD , 2011 , pp. 709 { 720 .

34. Zazhir , J. , El Qadi , A. , Bellatreche , L. , 'Identifying SQL Queries Similarity Using SVM' , in Proc. of ICONIP , 2015 .

35. Zeitler , E. , Risch , T. , 'Scalable Splitting of Massive Data Streams' , in DASFAA 2010 , vol 5982 , Springer, 2010 .

36. Zhang , Z. , et al., 'Boolean + ranking: Querying a database by k-constrained optimization' , in Proc. ACM SIGMOD , 2006 .