Model-based ApproximateQuery ProcessingMoritz Kulessa1, Alejandro Molina1, Carsten Binnig1,2, Benjamin Hilprecht1, Kristian Kersting1

1 TU Darmstadt, Germany 2 Brown University, USA

ABSTRACTInteractive visualizations are arguably the most important toolto explore, understand and convey facts about data. In the pastyears, the database community has been working on differenttechniques for Approximate Query Processing (AQP) that aimto deliver an approximate query result given a fixed time boundto support interactive visualizations better. However, classicalAQP approaches suffer from various problems that limit the ap-plicability to support the ad-hoc exploration of a new data set:(1) Classical AQP approaches that perform online sampling cansupport ad-hoc exploration queries but yield low quality if exe-cuted over rare subpopulations. (2) Classical AQP approaches thatrely on offline sampling can use some form of biased samplingto mitigate these problems but require a priori knowledge of theworkload, which is often not realistic if users want to explore anew database.

In this paper, we present a new approach to AQP called Model-based AQP that leverages generative models learned over thecomplete database to answer SQL queries at interactive speeds.Different from classical AQP approaches, generativemodels allowus to compute responses to ad-hoc queries and deliver high-quality estimates also over rare subpopulations at the same time.In our experiments with real and synthetic data sets, we show thatModel-based AQP can in many scenarios return more accurateresults in a shorter runtime. Furthermore, we think that ourtechniques of using generative models presented in this paper cannot only be used for AQP in databases but also has applicationsfor other database problems including Query Optimization aswell as Data Cleaning.

1 INTRODUCTIONMotivation: Interactive visualizations are arguably the most

important tool to explore, understand and convey facts about data.For example, as part of data exploration visualizations are used toquickly skim through the data and look for patterns [10, 20]. Thisrequires to generate a sequence of visualizations and allow theuser to interact with them. Figure 1 shows an example screenshotof an interactive data exploration session over the Titanic dataset1. First, the user analyzes the distribution of passengers byregion (leftmost) in a type of a choropleth map visualization,then he looks at the histogram of the age of passengers (topmost).Afterwards, he selects only those passengers that are from certaincountries in Europe or above the age of 25, and looks at thedistribution between males and females in form of a pie chart(middle). Finally, the user selects only the female passengers andshows the average rate of survived passengers (right).

All of these scenarios require interactive visualizations thatquickly react to a given user interaction (e.g., restricting the datausing a given filter condition). Unfortunately, when the data sets

1http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.html

© 2019 Copyright held by the owner/author(s). Published in Proceedings of the22nd International Conference on Extending Database Technology (EDBT), March26-29, 2019, ISBN XXX-X-XXXXX-XXX-X on OpenProceedings.org.Distribution of this paper is permitted under the terms of the Creative Commonslicense CC-by-nc-nd 4.0.

age

regionsex

survived

OR

Figure 1: Interactive data exploration session.

are larger, computing a single visualization can take seconds oreven minutes, creating a significant barrier to interactive dataanalysis. A recent study [16] has shown that visual delays of500ms tend to decrease both end-user activity and data set cov-erage, due to the reduction in rates of user interaction that iscrucial for overall observation, generalization and hypothesis.Maybe surprisingly, traditional database systems are ill-suitedfor speeding up visualizations and can not guarantee interactiveresponse times especially since data sizes are growing constantly.

The database community has been working on different tech-niques for Approximate Query Processing (AQP) that aim todeliver an estimate of the query result given a fixed time bound.In the past, different techniques for AQP have been proposedincluding approaches that leverage pre-computed samples orsynopses as well as techniques that sample from the underlyingdata at query runtime. However, all the existing AQP approachessuffer from various limitations that restrict the applicability tosupport the ad-hoc exploration of a new data set [6]: (1) AQPapproaches that are based on online sampling (e.g., DBO [13],CONTROL [11], approXimateDB [14]) are able support ad-hocqueries on the one hand but on the other hand can only providegood approximations for queries over the mass of the distribu-tion, while queries over rare sub-populations yield results withloose error bounds or even result in missing values in the queryresults. (2) AQP approaches that rely on offline sampling canuse some form of biased sampling to mitigate this problem (e.g.,AQUA [1], BlinkDB [2]), but therefore usually require a prioriknowledge of the workload which is often not realistic if userswant to explore a new database using ad-hoc queries.

Contribution: In this paper, we present a new approach to AQPcalledModel-based AQP that leverages generative models learnedover a given database to answer SQL queries at interactive speeds.Generative models are an unsupervised approach for statisticalmodeling to learn the joint probability distribution of a givendata set. Different from discriminative models, any attribute of adata set can be used as a target variable for prediction. To thatend, generative models can capture the characteristics over thecomplete database in a succinct manner without making anyprior assumptions. Different from other AQP approaches thatrely on pre-computed samples or synopses, generative models

arX

iv:1

811.

0622

4v1

[cs

.DB

] 1

5 N

ov 2

018

Online (at Runtime)Offline

Database Generative Model Q2: Select AVG(net(salary)) From Census Where Gender = FemaleAND salary >=500k

Q1: Select COUNT(*) From Census Where Gender = FemaleAND salary >=500k

P(gender=female)*|Census|=0.0001*1m

sample-salary

700k

700k

1m

AVG(net(sample-salary))=640k

Sample-based

Probability-based

Figure 2: Overview of model-based AQP.

can deliver high-quality estimates for arbitrary ad-hoc querieseven for rare sub-populations.

Therefore, we explain intuitively how generative models canbe used to answer SQL queries in an approximate manner. Themain idea is that generative models are either able to directlyprovide probability estimates that can be used to compute the re-sults of simple aggregate queries or to generate samples for morecomplex queries that could even include user-defined functions.Since generative models capture the joint probability distributionof the complete underlying data set, both these approaches (i.e.,probability estimation as well as sample generation) can guaran-tee good estimates even for rare sub-populations as we will showin our experimental evaluations. For example, for sample genera-tion, we use the information in the model to generate stratifiedsamples on-the-fly at query time and thus can guarantee thatsamples are generated even for rare sub-populations.

In summary in this paper wemake the following contributions:(1) To the best of our knowledge, we are the first paper thatdiscusses the possibilities of how generative models can be usedfor approximate query processing. (2) We present two differentquery processing strategies on top of generative models: onebased on probability and expectation estimates and one based onsampling. (3)We analyze the different query processing strategiesusing an extensive experimental evaluation based on real andsynthetic data sets.

We believe that the basic idea of using generative models isnot only applicable for AQP, but also represents a more generalapproach that can also be used for other query-processing relatedproblems including cardinality estimation for query optimizationor to build more robust query answering strategies that toleratedata errors (e.g., by generating data for missing values duringquery processing).

Outline: The remainder of this paper is organized as follows: InSection 2, we first give an overview of Model-based AQP and dis-cuss the requirements a generative model has to fulfill to be usedfor AQP. Afterward, we explain Mixed Sum-Product-Networksin Section 3, a particular class of generative models that satisfiesthese requirements. We then show how SQL queries can be com-piled into an inference procedure using Sum-Product-Networksin Section 4 and then explain the two different AQP executionstrategies using SPNs in Sections 5 and 6. To show the efficiencyof Model-based AQP, we present our evaluation results usingbenchmarks on real and synthetic data sets in Section 7. Finally,

we discuss related prior work in Section 8 and then conclude bydiscussing planned future extensions in Section 9.

2 OVERVIEW2.1 Model-based AQPThe main idea of Model-based AQP is shown in Figure 2. Thegenerative model is built once over the original (potentially large)database and then used to answer SQL queries for data explo-ration in an interactive manner. The general approach of Model-based AQP is thus similar to classical AQP creating a sampleoffline, which is used at runtime to answer queries. However,different from the sampling-based approaches Model-based AQPdoes not need to know the workload (i.e., queries) to deal withrare sub-populations. In this paper, we support aggregate SQLqueries with and without filter predicates as well as with andwithout group-by statements for Model-based AQP. Furthermore,we support user-defined functions and general arithmetic ex-pressions to be used instead of base attributes. Joins and nestedqueries are not covered in this paper, but represent an interestingavenue for future work.

For approximate query processing, Model-based AQP providesdifferent strategies as shown on the right-hand side of Figure 2:a probability-based strategy and a sample-based strategy. Asshown on the right-hand side for query Q1, the probability-basedstrategy translates the given SQL query directly into an inferenceprocedure and uses the resulting probability as well as statistics(i.e., the size of the table) to answer the query. The sample-basedstrategy instead is shown for query Q2. In this strategy the modelis used to generate samples and then the samples are used toanswer the query.

Indeed, the probability-based strategy is more efficient thanthe sample-based strategy but can only be used for simple ag-gregate queries without user-defined functions or arithmeticexpressions and only supports conjunctive predicates (i.e., thenet salary in the example). Moreover, both strategies can deliverestimates efficiently for rare sub-populations (e.g., the femaleswith salary above a 500k as shown in Figure 2) without knowingthe workload ahead of time. In our experimental evaluation, weshow that both strategies outperform classical online samplingon skewed data not only in terms of runtime but also in thequality of the approximated results.

In this work, we focus on pure analytical workloads where datais not updated online such as in data warehouses. We therefore

λ1gender

λsalary

✕

λgender

✕

+0.3

P (gender)=λ1

0.7 {0.2, if gender=male0.8, if gender=female

λsalary

P (gender)=λ3 {0.7, if gender=male0.3, if gender=female

2 3 4 250k 500k 750k 1m

0.4

0.2

0.0250k 500k 750k 1m

0.4

0.2

0.0

P (salary)λ2 P (salary)λ4P

salary salary

P

Figure 3: Example SPN over variables gender and salary.

assume that a new SPN can be learned every time a new bulk ofdata is loaded into the database. However, this can be improvedsince no new SPN needs to be learned if the statistical propertiesof the data after the update do not change. In this case, we canreuse the same SPN and only need to update the statistics (i.e.,table sizes). Detecting this case efficiently is an interesting avenuefor future work though.

2.2 Model RequirementsAn essential requirement for Model-based AQP is that a gener-ative model must enable tractable inference in hybrid domains,consisting of mixed-continuous, discrete and/or categorical dis-tributions to support arbitrary database schemata. Sum-ProductNetworks (SPNs) [19] fulfill the tractability requirements and aretherefore are a suitable candidate for AQP. In contrast to otherprobabilistic models, SPNs can efficiently compute a large classof probabilistic queries [19].

Furthermore, SPNs can generate samples, provide normalizedprobabilities and expectation estimates with a complexity linearon the size of the model. In particular, they are capable of rel-evance sampling, i.e., they can generate samples for a specificsub-population. However, the drawback of SPNs is that the para-metric form of the distributions of the features has to be specifiedin advance [17]. This can be quite challenging and time consum-ing especially for hybrid domains which involve continuous anddiscrete random variables at the same time [17].

For that reason, we use so calledMixed-Sum Product Networks(MSPNs) [17]. MSPNs are a general class of mixed probabilisticmodels that, by combining Sum-Product Networks and piecewisepolynomials, allow for a broad range of exact and tractable infer-ence without making strong distributional assumptions. Hence,MSPNs require only knowledge about the statistical types of therandom variables, fortunately, this is available in the databaseschema which makes them an ideal candidate for AQP.

3 MIXED SUM-PRODUCT NETWORKSMSPNs (for simplicity we will only use the term SPN in thefollowing) learn the probability distribution P(X1,X2, . . . ,Xn )of the variables X1, . . . ,Xn which are present in the dataset. Forexample in Figure 3 the SPN is defined over the discrete variablegender and the continuous variable salary.

SPNs are rooted acyclic graphs with sum and product nodesas internal nodes and leaves defining probability distributions forsingle variables [19]. Intuitively, sum nodes split the populationinto subgroups and product nodes split independent variables ofa population. For example in Figure 3 the top sum node splits thecensus data into two groups: The left group which is dominatedby women and high salaries and the right group with more menand lower salaries. In each of these groups salary and genderare independent and hence split by a product node. The leave

nodes determine the probability distributions of the variablesgender (Pλ1(gender) and Pλ3(gender)) and salary (Pλ2(salary) andPλ4(salary)) for every group. Linear interpolations (red) of thehistograms are used in leaf nodes for continuous variables toapproximate the true probability distribution.

The scope of a node is defined as the set of variables occur-ring in the underlying leaf nodes. For example in Figure 3 thescope of the nodes λ1 and λ3 is {gender} and the scope of theproduct and sum nodes is {aдe,дender }. A SPN representing avalid probability distribution can now be defined recursively [17]:(1) A tractable distribution over a single variable is a SPN, (2) aproduct of SPNs which are defined over different scopes is a SPNand (3) a sum of SPNs which share the same scope is a SPN.

In the following, we explain the two basic building blocks ofhow SPNs can be used for AQP; i.e., (1) how to estimate probabil-ities and expectations for given sub-populations and (2) how togenerate samples for a given sub-population. Finally, we discusspotential optimizations to enable more efficient AQP.

3.1 Inference ProcedureTo answer probabilistic queries in a SPN, we evaluate the nodesstarting at the leaves. Given some evidence, the probability out-put of the leaf distributions is propagated bottom up. For productnodes, the values of the children nodes are multiplied and prop-agated to their parents. For sum nodes, instead, we sum theweighted values of the children nodes. The value at the root indi-cates the probability of the asked query. To compute marginals,i.e., the probability of partial configurations, we set the probabil-ity at the leaves for irrelevant variables to one and then proceedas before. Especially when dealing with SQL queries, not all vari-ables are usually of interest for answering a query. Conditionalprobabilities can then be computed as the ratio of partial config-urations.

Assume we want to estimate the probability that a memberof the census data is a women earning more than 500k. The re-spective conditions would be Cgender = {female} and Csalary =

{[500k, 1m]}. In order to estimate the probability P(Cgender ∧Csalary)we first apply the gender condition to all leave nodes withscope {gender}. The probabilities for the discrete random variablegender are simply Pλ1(gender=female) = 0.8 andPλ3(gender=female) = 0.3. For the continuous variable, the proba-bilities are approximated with the linear interpolations of the his-tograms. Let us assume the probabilities are Pλ2(500k ≤ salary ≤1m) = 0.7 and Pλ4(500k ≤ salary ≤ 1m) = 0.3. In the bottom-uppass we obtain P(Cgender ∧Csalary) = 0.231.

Another essential building block for this work is the ability ofSPNs to compute expectations E[Xi |C1∧· · ·∧Cn ] for a variableXiand given conditionsC1 toCn . Similar to the computation of theprobability, the expectation is computed in a bottom-up processstarting at the leaves of the SPN. For all leaves with scope {Xi },

the expectation of the respective distribution is evaluated whilefor all other variables inference is computed according to theconditions. In the case of computing the expectation on a sub-population of the data, the result obtained at the root node needsto be normalized according to the probability P(C1 ∧ . . . ∧Cn ).

3.2 Sample CreationWe first explain how random sampling without any conditionsworks. Let |S | denote the number of samples that should be gen-erated with the help of the SPN. The intuition of sum nodes isthat they describe different sub-populations. Hence, every childof a sum node has to generate samples proportional to the weight.For a sample size |S | of 100 in Figure 3, approximately 30 sam-ples would be generated by the left sub-SPN and 70 samples bythe right sub-SPN. The children of product nodes have disjointscopes. Hence, one can sample from the children independentlyand concatenate the results of the different scopes. For example,for the left sub-SPN a gender would be drawn from Pλ1 and asalary from Pλ3. Both values would be combined to constituteone of the 30 samples of the left sub-SPN.

The most valuable property of SPNs for AQP is the ability togenerate biased samples, i.e. samples that satisfy conditions C1to Cn . This requires an additional initialization step. In this step,the weights of the sum nodes are adjusted. For every child node,the weight is multiplied with the probability P(C1 ∧ · · · ∧ Cn )computed on the sub-SPN of the child node. Afterwards, theweights of the sum nodes have to be normalized so that they sumup to one. For example, if only women should be sampled fromthe SPN of Figure 3 the left weight of the sum node becomes0.3 ∗ Pλ1(дender = f emale) = 0.3 ∗ 0.8 = 0.24 and the rightweight 0.7 ∗ Pλ3(дender = f emale) = 0.7 ∗ 0.3 = 0.21. As theweights do not sum up to one they have to be scaled resulting ina left weight of 0.53 and a right weight of 0.47. After this step,we can use the same algorithm as for random sampling with theonly difference that leaf nodes are restricted to values satisfyingthe conditions.

3.3 Optimizations for AQPCreating samples for continuous random variables in a SPN re-lies on rejection sampling [17]. However, rejection sampling isknown to be computationally inefficient since many sample can-didates need to be created before a candidate is accepted. For thatreason, we modified the basic structure of SPNs to store alreadya materialized sample of data in the leave nodes for continuousattributes instead of the distribution. That way, sampling can usethe SPN as an index and directly use the original data for samplecreation as we will discuss in Section 6.

Another way to improve the efficiency of SPNs is to marginal-ize the SPN to the set of variables which are relevant for thequery. We simply cut off all the child nodes of the SPN that con-tain irrelevant variables. In particular, if the query only operateson a few variables, the size of the SPN can be reduced signifi-cantly. Especially for sampling this is very useful because weavoid generating values for irrelevant variables. Moreover, aftercutting off the irrelevant child nodes, the structure of the SPNcan be further collapsed by combining sum nodes or removingproduct nodes.

4 QUERY COMPILATIONIn the following, we explain how the filter E and the grouping Gof an aggregation query as shown in Listing 1 can be compiled

into conditions for an SPN (i.e., to compute a probability or createsamples as discussed before).

Listing 1: Basic SQL-query with an aggregation.SELECT G, AGGR(A) FROM T WHERE E GROUP BY G

The details on how the conditions are used to compute theactual query result in an approximate manner will be discussedin Sections 5 to 6.

4.1 Filter PredicatesThe filter predicate E defines the sub-population of the data whichthe SQL query needs. The compilation of a simple predicate of theform att OP const where att is an attribute of the table T,OP is oneof the operators {=,,, <, ≤, >, ≥} and const is a constant from thedomain of att is straightforward by transforming the predicateinto a set of possible values for discrete random variables or a setof value ranges for continuous random variables. However, thepredicate E can contain a conjunctive or disjunctive combinationof conditions on same or different columns. Since we are only ableto process conjunctive conditions with a SPN, these combinationsneed to be handled differently which we examine in the followingsections.

In the case of conjunctive conditions, we extract the set ofpossible values or value ranges for each particular conditionindependently. If multiple conditions are applied to the samecolumn, the intersection of the extracted sets is used. As a result,we obtain a condition for each particular column of the filterwhich can then be used by a SPN.

When dealing with disjunctive conditions, we have to con-sider two cases: (1) The conditions are either applied to the samecolumn or (2) the conditions are applied to different columns.In the first case, we take the union of the extracted sets. How-ever, the second case needs to be handled in a particular mannerbecause an SPN is not able to process queries with disjunctiveconditions on different random variables. Therefore, the disjunc-tive condition needs to be transformed into multiple conjunctiveconditions by using the addition rule.

4.2 Group-by AttributesIn order to translate a grouping condition, we need to know adistinct list of group-by values д ∈ G. The distinct list of group-by values д can be efficiently derived from the SPN directly. Foreach particular group-by value д, a separate query needs to becomputed on each of the specified sub-populations of the data.The result of the group-by is then the union of all queries.

5 STRATEGY I: PROBABILITY-BASEDFirst, we want to introduce a query execution strategy that relieson expectation and probability estimations using the SPN as dis-cussed in Section 4. This strategy is preferred since no sampleshave to be drawn and thus it is the most efficient strategy. How-ever, it is only applicable to simple aggregate queries with nouser-defined functions and exclusively conjunctive predicates.

As already stated in the previous section, a given SQL querycan be parsed to obtain conditions corresponding to the filterpredicate E and the group-by attributes G. Depending on theaggregation function, we have to perform different computationswith the SPN. In the following, we discuss the details of thecomputation for the aggregation functions COUNT, AVG andSUM. Table 1 summarizes the results. MIN and MAX as well as

other aggregation functions are currently not supported similarto other AQP approaches.

5.1 COUNTIn order to provide an answer for a query with the aggregationfunction COUNT we have to determine the number of entries ofthe queried sub-population defined by E. This can be estimatedby multiplying the table size |T | with the probability for the sub-population P(E). Moreover, in case of a grouping we additionallyhave to analyze this sub-population with respect to the individualgroups д defined by G.

Equation 1 shows how the results for each particular groupд ∈ G are computed. The probability P(E ∧ д) represents thata record fulfills the filter condition E and is in the group д ismultipliedwith the table size. In case that E andд share conditionson same columns, these conditions are combined by taking theintersection of the set of possible values or value ranges.

P(E ∧ д) ∗ |T | (1)

In case the query does not specify a group-by statement, thecomputation simplifies to P(E) ∗ |T |.

5.2 AVGFor the computation of an AVG aggregation, we rely on the func-tionality of SPNs to compute expectations. Like for the estimationof a COUNT aggregation we first have to parse the SQL-query toobtain the conditions for the sub-population E and the groupingG. In addition, we need to extract the columns of A on whichthe aggregation is applied. In case that A is an arithmetic expres-sion of columns, a result for the query can only be computed ifonly the operators for addition and subtraction are used. Withrespect to these operators, we first compute the expectation forevery single column of A individually which are then added orsubtracted afterwards. In contrast, arithmetic expressions withmultiplication and division operators cannot be computed withthe probability-based approach. The computation for each partic-ular group д ∈ G according to the sub-population E is displayedin Equation 2.

E(A|E ∧ д) (2)

5.3 SUMThe computation of the result for a SUM aggregation can bereduced to the computation of a COUNT and an AVG aggregationby multiplying the respective results. Equation 3 represents thecomputation of a SUM aggregation based on the queried sub-population E and the grouping G . For the same reason as for theAVG aggregation, the SUM aggregation can only be applied onsingle columns and on arithmetic expression of columns whichuse the operators addition and subtraction. In any other case, noresult with the probability-based approach can be computed andthe sample-based approach, which is discussed next, will be used.

E(A|E ∧ д) ∗ P(E ∧ д) ∗ |T | (3)

6 STRATEGY II: SAMPLE-BASEDIn addition to the probability-based approach, the ability to gen-erate samples with a SPN offers us another way to approximate

Table 1: Aggregations for probability-based AQP.

Aggregation Computation for each group д ∈ G

COUNT P (E ∧ д) ∗ |T |AVG E(A |E ∧ д)SUM E(A |E ∧ д) ∗ P (E ∧ д) ∗ |T |

the result for more complex aggregation queries which use user-defined functions, arithmetic expressions or disjunctive predi-cates. Contrary to classical sample-based approaches for AQP,we can produce biased samples online at query runtime with theSPN, which is one of the significant advantages of SPNs. In thiswork we propose three different sampling techniques which areexplained in the following sections.

6.1 Random SamplingFirst, as a baseline we introduce the generation of random sam-ples with the SPN for which we use the sample functionalityof the SPN without specifying any conditions. Like for classicalrandom sampling from data, we face the issue that samples canbe generated which are not relevant for answering the submit-ted query. In particular, if the SQL query is only applied to asmall sub-population of the data, many generated samples arediscarded.

Using random samples, the query result can be approximated.In case of an AVG aggregation, no modifications have to be madesince the result of an AVG aggregation is independent of thenumber of entries on which it is computed. In contrast, COUNTand SUM aggregations depend on the number of samples onwhich they are computed. Therefore, we have to scale-up theresult of these aggregations to get the approximation. This isdone by multiplying the result with the total number of entriesof the data divided by the number of the samples which havebeen generated. We refer to this multiplier asmrandom and it isgiven in Equation 4.

mrandom =|T ||S | (4)

6.2 Relevance SamplingIn order to avoid the generation of irrelevant samples, we useanother more advanced approach called relevance sampling. Thisapproach only generates samples for the queried sub-populationdefined by the filter E. Compared to the random sampling ap-proach, we can improve the efficiency of approximating the result,especially for rare sub-populations, since we do not have to dis-card any samples. For example, if only 1% of the data is relevantfor the SQL query, then the relevance sampling approach is onehundred times more efficient than the random sampling approachto obtain the same precision for the approximation.

Due to the sample generation, the approximation of the resultfor the aggregation is different compared to random sampling.To scale-up the result of COUNT and SUM aggregation queries,we further need to multiply the result with the probability P(E)of the sub-population of the data. This probability is obtainedby performing inference for the sub-population specified by thefilter E. The respective multiplier used to scale-up the result iscomputed asmr elevance in Equation 5.

mr elevance =|T ||S | P(E) (5)

P (filter = 1) = 25% P (A = 1 |filter = 1) = 20% P (A = 1 |filter = 2) = 70% P (A = 1 |filter = 3) = 90% P (A = 1 |filter = 4) = 99% P (B |A = 1) = N (µ = 100, σ = 20)P (filter = 2) = 25% P (A = 2 |filter = 1) = 20% P (A = 2 |filter = 2) = 20% P (A = 2 |filter = 3) = 6% P (A = 2 |filter = 4) = 0.6% P (B |A = 2) = N (µ = 110, σ = 20)P (filter = 3) = 25% P (A = 3 |filter = 1) = 20% P (A = 3 |filter = 2) = 6% P (A = 3 |filter = 3) = 3% P (A = 3 |filter = 4) = 0.3% P (B |A = 3) = N (µ = 120, σ = 20)P (filter = 4) = 25% P (A = 4 |filter = 1) = 20% P (A = 4 |filter = 2) = 3% P (A = 4 |filter = 3) = 0.9% P (A = 4 |filter = 4) = 0.09% P (B |A = 4) = N (µ = 130, σ = 20)

P (A = 5 |filter = 1) = 20% P (A = 5 |filter = 2) = 1% P (A = 5 |filter = 3) = 0.1% P (A = 5 |filter = 4) = 0.01% P (B |A = 5) = N (µ = 140, σ = 20)

Figure 4: Probability distributions of the synthetic dataset.

6.3 Stratified SamplingThe relevance sampling approach is already amajor improvementfor the approximation of aggregation results compared to randomsampling but it ignores the grouping of the SQL query. Eachspecific queried group should obtain an approximation as fast aspossible. However, the relevance method does not consider theselectivity of the queried groups which can be skewed. Hence,particular groups will obtain more samples to approximate theresult than other groups which has an effect on the precision ofthe approximations.

This problem can be solved with the stratified sampling ap-proach which can generate samples for each particular group дindependently. We introduce the notation |S(д)| representing thenumber of samples which need to be generated for a group д.In general, the total number of samples to generate is evenlydistributed among the groups. However, in order to avoid over-representation of rare sub-populations we restrict to generatemore samples for a group than samples are available for thatgroup in the original data. This information can be obtained byperforming inference on the SPN with the conditions for thatparticular group. The remaining number of samples, which havebeen cut off, are distributed evenly over the other groups, forwhich the same restriction is applied.

Similar to relevance sampling, we have to adapt the computa-tion of the approximation, because we rely on biased sampling.Since we are generating the samples for each group indepen-dently, the aggregation result has to be approximated for eachgroup on its own. The multipliermstratif ied (д) for each partic-ular group д is given in Equation 6. Similar to the other proposedsampling approaches, the multiplier only needs to be applied toscale-up the result of the COUNT and SUM aggregations.

mstratif ied (д) =|T |

|S(д)| P(E ∧ д) (6)

7 EXPERIMENTAL EVALUATIONA key aspect of our experimental evaluation is to demonstratethat our proposed AQP techniques based on SPNs are superior torandom sampling from data. Therefore, we have first evaluatedthe efficiency of our approaches on a real dataset with differ-ent sizes. Furthermore, we executed additional experiments onsynthetic data to show how our proposed approaches behave byvarying the selectivity of particular SQL queries. Similarly, wehave evaluated the effect of skewness of the group-by attributeson the approximations as well as how the quality of the learnedmodel with respect to different parameter settings influencesquery results.

In the following we first explain the experimental setup (met-rics, data sets, queries as well as other important settings) beforewe discuss the results of our experimental evaluations.

Table 2: Statistics about the datasets.

name #instances size in #discrete #continuousmegabyte columns columns

flights100K 100,000 5.55 6 6flights1M 1,000,000 55.52 6 6flights10M 10,000,000 555.21 6 6synthetic 1,000,000 23.29 2 1

Table 3: Statistics about the queries.

identifier aggregation groups selectivity (in %) skewness

F 1.1 AVG 1 ∼ 5.6000 -F 1.2 AVG 1 ∼ 1.3800 -

F 2.1 COUNT 26 ∼ 1.0000 1.4343F 2.2 COUNT 26 ∼ 0.1260 1.4122F 2.3 COUNT 22 ∼ 0.0140 0.4719

F 3.1 SUM 22 ∼ 1.0000 0.0329F 3.2 SUM 53 ∼ 0.1200 2.4420F 3.3 AVG 26 ∼ 0.1500 1.4735

F 4.1 COUNT 53 ∼ 1.3600 2.4234F 4.2 COUNT 26 ∼ 0.1000 1.5480

S 1.1 COUNT 5 ∼ 25.0000 -0.3851S 1.2 COUNT 5 ∼ 25.0000 1.2751S 1.3 COUNT 5 ∼ 25.0000 1.4876S 1.4 COUNT 5 ∼ 25.0000 1.4999

S 2.1 AVG 5 ∼ 25.0000 -0.3851S 2.2 AVG 5 ∼ 25.0000 1.2751S 2.3 AVG 5 ∼ 25.0000 1.4876S 2.4 AVG 5 ∼ 25.0000 1.4999

S 3.1 COUNT 1 ∼ 5.0000 -S 3.2 COUNT 1 ∼ 0.2500 -S 3.3 COUNT 1 ∼ 0.0250 -S 3.4 COUNT 1 ∼ 0.0025 -

S 4.1 AVG 1 ∼ 5.0000 -S 4.2 AVG 1 ∼ 0.2500 -S 4.3 AVG 1 ∼ 0.0250 -S 4.4 AVG 1 ∼ 0.0025 -

7.1 Setup and WorkloadMetrics: For reporting the metrics, we have repeated each

experiment ten times and averaged the results. Besides measuringthe time to provide an estimate for an aggregation query, weuse two evaluation measures in order to evaluate the quality ofapproximation results which we have taken from [5]. We denoteG as the actual result of an aggregation which is commonlyknown as the ground truth. Furthermore, we define Gдroups asa set which contains all the groups which appear in the results.In order to access the result for a specific group i we denoteGvalues (i). Similar to this notation we represent the result for theapproximation of an aggregation as A, Aдroups and Avalues (i).

First of all, an approximation algorithm is not always ableto provide approximations for all groups which appear in theground truth. In order to measure the coverage of the groups inthe approximation, we use the measure bin completeness whichis defined in Equation 7.

F1.2 F1.2 F2.1 F2.2 F2.3 F3.1 F3.2 F3.3 F4.1 F4.20.00

0.25

0.50

0.75

1.00

aver

age

rela

tive

erro

r

exact SQLrandom sampling datarandom sampling SPNrelevance sampling SPNstratified sampling SPNprobability-based SPN

F1.2 F1.2 F2.1 F2.2 F2.3 F3.1 F3.2 F3.3 F4.1 F4.20.0

0.5

1.0

exec

utio

n tim

ein

seco

nds

Figure 5: Results of the average relative error and the execution time for all queries on dataset flights10M.

bin completeness =|Gдroups −Aдroups |

|Gдroups |(7)

On the other hand, we examine the quality of the approxi-mation by using the relative error which represents the relativedifference between the approximated value and the actual valuefor a particular group. The relative error for a group i can onlybe computed if Gvalues (i) and Avalues (i) exist, therefore, it canonly be applied on the set X = Gдroups ∩ Aдroups . In order toobtain a measure for the whole query, we average the relativeerror for all groups resulting in the average relative error whichis displayed in Equation 8.

avg. relative error =1|X |

∑i ∈X

|Gvalues (i) −Avalues (i)||Gvalues (i)|

(8)

Datasets: On the one hand, we evaluated our proposed AQPtechniques on a real-world dataset (called flights database) whichwe have taken from [5]. This dataset represents basic informationabout particular flights which have been tracked over a couple ofyears. In order to evaluate different sizes of the dataset we haveused the data generator proposed by [5] which has the ability toscale a given dataset to a specific size. On the other hand, we havegenerated a synthetic dataset in order to directly measure theeffect of selectivity and skewness on the quality of approximationresults when using our approach compared to the other baselines.For that purpose, we have created a dataset with three columns,named A (used for grouping), B (used for aggregation) and filter(used for the predicate). Depending on the filter condition, theresulting distribution of the group-by attributes is either uniformor skewed to a certain degree. Furthermore, correlations betweenthe columns A and B exist. The underlying probability distribu-tion of the synthetic dataset is shown in Figure 4. Basic statisticsof the two datasets can be found in Table 2. We decided not to usestandard synthetic benchmarks like TPC-H since they are neitherreal data nor do they allow to change different parameters suchas skeweness and correlation which we wanted to vary in ourexperiments.

Queries: In order to evaluate our approaches on a wide varietyof different queries, we provide ten queries for the flights datasetand twelve queries for the synthetic dataset which can be foundin the appendix. These queries mainly differ in the number andtypes of columns they are applied on, the aggregation function,

the selectivity of the queried sub-population and the skewnessof the grouping. A particular focus of our evaluation is basedon queries with a very low selectivity. Basic statistics about thequeries are displayed in Table 3. The skewness for the groupingis computed with Equation 9 in which Y contains the selectivityfor each group of the query.

skewness(Y ) =∑ |Y |i=1(Yi − Y )3/|Y |

std(Y )3(9)

Implementation: In order to show the effects of our Model-based approaches compared to classical query processing approach-es in terms of runtime and quality, we have implemented all pro-totypes in a single-threaded query execution engine. As a firstbaseline, we have implemented a query execution engine thatcan execute SQL queries in an exact manner using in-memoryarrays to store the database. Additionally, we used the same en-gine but implemented a simple random sampling procedure andused online aggregation to compute approximate query resultsas described in [12]. For the evaluation of our Model-based AQPtechniques, we loaded the SPNs into memory before execution.Hence, all mentioned algorithms maintain their respective datain memory.

7.2 Exp. 1: Overall EfficiencyOne major aspect of our experimental evaluation is to compareour proposed AQP techniques with random sampling from dataand exact SQL. For that purpose, we have evaluated all AQPapproaches on the dataset flights10M. In particular, for the sample-based approaches, the idea of this experiment is to report theexecution time of the queries until the average relative error isbelow 5% and full bin completeness is achieved. Therefore, wegenerate samples until the specified goal or the limit of 100, 000instances is reached. In case that the limit is reached, we stopthe sampling procedure and report the error of the results whichis achieved with the respective number of samples. Since exactSQL and the probability-based approach do not rely on samples,we only report the average relative error and the execution timefor these approaches.

The results for the average relative error and the executiontime for all evaluated queries are visualized in Figure 5. Our firstand foremost observation is that our proposed approaches areable to process the queries with typically less computation timecomapred to exact SQL and better accuracy compared to random

Table 4: Average relative error of the probability-based approach on different sizes of the dataset flights.

size of dataset F 1.1 F 1.2 F 2.1 F 2.2 F 2.3 F 3.1 F 3.2 F 3.3 F 4.1 F 4.2

100, 000 0.000757 0.008604 0.249744 0.456241 0.415543 0.090410 0.437463 0.006803 0.269545 0.7283701, 000, 000 0.000315 0.002836 0.081535 0.263019 0.548479 0.043265 0.322761 0.003539 0.126056 0.156574

10, 000, 000 0.000026 0.003425 0.033385 0.064262 0.105324 0.016804 0.097058 0.002170 0.043148 0.072445

100,000instances

1,000,000instances

10,000,000instances

0.00.20.40.60.81.01.21.4

exec

utio

n tim

e in

seco

nds exact SQL

random sampling datarandom sampling SPNrelevance sampling SPNstratified sampling SPNprobability-based SPN

(a) F1.2

100,000instances

1,000,000instances

10,000,000instances

0.00.20.40.60.81.01.21.4

exec

utio

n tim

e in

seco

nds

(b) F2.3

100,000instances

1,000,000instances

10,000,000instances

0.00.20.40.60.81.01.21.4

exec

utio

n tim

e in

seco

nds

(c) F3.2

100,000instances

1,000,000instances

10,000,000instances

0.00.20.40.60.81.01.21.4

exec

utio

n tim

e in

seco

nds

(d) F4.2

Figure 6: Runtime of the approaches on different sizes of the dataset flights.

sampling. Furthermore, we could observe that the execution timeof the stratified sampling approach and the probability-based ap-proach depends on the number of groups in a query. In particular,we found out that the execution time of these approaches for thequeries F3.2 and F4.1 is higher than for the other queries. Thereason for this is that each group needs to be handled individuallyby these approaches.

In addition, we detect a minor increase of the runtime in thecase that the query contains conditions on continuous columns(e.g. query F4.2 contains two continuous columns). This is dueto the fact that for continuous columns more values need to beaccessed in the leaves to process the query. On the other hand,for discrete columns the values in the leaves can be representedcompactly by frequency distributions and accessed quickly.

Moreover, if we compare the execution time of the randomsampling approaches we can see that for the creation of manysamples the sampling from the SPN is much more efficient thanfrom data while the quality of the approximations is similar. Byusing the SPN, we avoid dealing with huge amounts of data andwe only generate samples which are relevant to answer the querywhich gives us a huge gain in efficiency. This suggests that, inparticular for big datasets, relevance sampling from the SPN canbe a better choice than random sampling from data.

According to the quality of the approximations, we can fur-ther observe that relevance sampling, stratified sampling andour probability-based approach outperform random sampling onalmost all queries. In particular on queries with a very low selec-tivity we can obtain a clearly better result of the average relativeerror with the exception of query F3.3. The result of this querycan be approximated precisely by all approaches but the randomsampling approaches fail to provide full bin completeness.

7.3 Exp. 2: ScalabilityAnother important question regarding our proposed AQP tech-niques is how they behave when they are applied on differentsizes of datasets. Therefore, we have used the dataset flights with100, 000, 1, 000, 000 and 10, 000, 000 instances on which we haverun all ten queries. Furthermore, we have evaluated random sam-pling from data and exact SQL in order to draw comparisons.As for the previous experiment, we produce samples with thesample-based approaches until the average relative error is below

Table 5: Statistics about the constructed SPNs for differentsizes of the dataset flights.

Dataset Construction time Relative size of Number ofin minutes SPN to data SPN nodes

flights100K ∼ 80 5.17% 901flights1M ∼ 174 1.20% 802flights10M ∼ 248 0.32% 850

5% and bin completeness is fulfilled with the constraint that amaximum of 100, 000 samples can be generated. Regarding theexact SQL and the probability-based approach, we only reportthe average relative error and the runtime of these approaches.

Statistics about the constructed SPNs on the different datasetsare displayed in Table 5. Here, we can observe that we can obtaina very good compression of the data, especially for the biggerdatasets. In particular, all SPNs share a similar amount of nodeswhich is caused by the same parameter configurations.

First of all, we examine the impact of the different dataset sizeson the execution time of the approaches. We have visualized theruntime for some selected queries in a grouped bar plot whichcan be seen in Figure 6. Each group represents a specific size ofthe dataset while the y-axis represents the execution time.

For exact SQL and random sampling from data, we can observethat the runtime for each different query on a particular dataset issimilar whereas the execution time between the different datasetsrises with respect to the size of the dataset linearly. This behaviorcan not be observed for the proposed AQP-techniques. In partic-ular, we only detect a minor increase of the runtime on biggerdatasets in the case that the query contains continuous columns(e.g. query F1.2 and F4.2). This can be explained by the fact thatthe constructed SPNs for the different datasets contain almost thesame amount of nodes. Therefore, the constructed SPNs mainlydiffer in the number of values which are stored in the leaves forcontinuous random variables. In the case of the bigger dataset,more values need to be accessed in the leaves to process the query.Thus the computation time is higher. In contrast, the executiontime of queries on only discrete columns is not affected by thesize of the dataset (e.g. query F2.3). As observed in the previousexperiment, we can also observe that the execution time of the

100 101 102 103

number of instances

0

1

2

3

4

5

rela

tive

erro

r

(a) SPN build on dataset flights100K.

100 101 102 103 104

number of instances

0

1

2

3

4

5

rela

tive

erro

r(b) SPN build on dataset flights1M.

101 102 103 104 105 106

number of instances

0

1

2

3

4

5

rela

tive

erro

r

(c) SPN build on dataset flights10M.

Figure 7: Relative error for all groups of all queries computed with the probability-based approach on different SPNs.

0 2000 4000 6000 8000 10000number of samples

0.01

0.02

0.03

0.04

0.05

0.06

aver

age

rela

tive

erro

r random sampling datarandom sampling SPNrelevance sampling SPNprobability-based SPN

(a) S4.1 (selectivity 5%)

0 2000 4000 6000 8000 10000number of samples

0.00

0.02

0.04

0.06

0.08

0.10

aver

age

rela

tive

erro

r

(b) S4.2 (selectivity 0.25%)

0 2000 4000 6000 8000 10000number of samples

0.04

0.06

0.08

0.10

0.12

0.14

aver

age

rela

tive

erro

r

(c) S4.3 (selectivity 0.025%)

0 2000 4000 6000 8000 10000number of samples

0.04

0.05

0.06

0.07

0.08

0.09

aver

age

rela

tive

erro

r

(d) S4.4 (selectivity 0.0025%)

Figure 8: Relative error of the sample-based approaches on the synthetic dataset with respect to the number of generatedsamples.

stratified sampling and the probability-based approach relies onthe number of groups of the query (e.g. query F3.2).

Apart from the execution time of the approaches, we canobserve a major improvement in terms of the quality of theSPN with an increasing size of the dataset. Indeed, the averagerelative error for all evaluated queries decreases drastically withan increasing size of the dataset. Since the probability-basedapproach can be used to measure the quality of the SPN wehave displayed the result of this approach for all queries and alldatasets in Table 4.

In order to understand the reason for the improvement of thequality, we have analyzed the approximation for each group ofthe queries in more detail. We have computed the relative errorfor each particular group with the probability-based approachand set it into relation with the number of instances for thatgroup in the actual dataset. We have done this procedure for allthree datasets and visualized the results in Figure 7. Here, they-axis represents the relative error of the group and the x-axisrepresents number of instances of that group in the actual dataset.

In the plots, we can observe that the relative error decreasessignificantly if the group contains more instances. Furthermore,we can see that the groups which are computed on the biggerdatasets contain much more instances than the groups of thesmaller datasets.

However, the relation between the relative error and the num-ber of instances for the groups among the results on the differentSPNs is the same. In particular, all groups which contain morethan 100 instances always have a relative error below 30%. Hence,we are able to obtain significantly better results with the SPNwhich is build on the dataset with ten million instances becausethe queried sub-population for a particular group contains moreinstances. In contrast, the groups of the dataset which rely on

100, 000 instances often contain only one or two instances foreach group. Therefore, we can conclude the relative error fora group computed with the probability-based approach highlydepends on the number of instances for that group. To sum itup, the quality of the approximations computed with an SPN isindependent of the size of the dataset on which it is built andmainly depends on the number of instances of the groups of aquery.

7.4 Exp. 3: Effect of SelectivityThe advantage of our proposed biased sampling approaches withrespect to the selectivity of a query is examined in this experiment.In order to directly measure the influence of the selectivity onthe quality of the approximations we have evaluated the queriesS3 and S4 with our proposed approaches on the synthetic dataset.For direct comparison, we additionally evaluated random sam-pling from data. For all the sample-based approaches, we havegenerated 10, 000 samples and tracked the relative error of theapproximation along the sample generation. Since the evaluatedqueries do not contain a grouping, the relevance and the stratifiedsampling approach are identical. Thus, we have not evaluatedthe stratified sampling approach for this experiment.

The first observation is that the result of the relevance sam-pling approach and the probability-based approach are the samefor the query S3 irrespective of the number of generated samples.The reason for this behaviour is that the scaling of the COUNTaggregation for the relevance sampling approach corresponds tothe computation of the COUNT aggregation with the probability-based approach.

The results for queries S4.1 to S4.4 are visualized in Figure 8where the x-axis represents the generated number of samples

Table 6: The average relative error of the probability-based approach for the queries S3 and S4 on the synthetic dataset.

setting S 3.1 S 3.2 S 3.3 S 3.4 S 4.1 S 4.2 S 4.3 S 4.4

SPN used in previous experiments 0.0000 0.1022 0.7404 2.9326 0.0119 0.0061 0.0574 0.0380SPN which assumes independence on all columns 0.7367 4.3573 51.2983 597.7825 0.2391 0.2408 0.2376 0.2183

0 2500 5000 7500 10000number of samples

0.04

0.06

0.08

aver

age

rela

tive

erro

r

0 2500 5000 7500 10000number of samples

0.5

0.6

0.7

0.8

0.9

1.0

bin

com

plet

enes

srandom sampling datarandom sampling SPNrelevance sampling SPNstratified sampling SPNprobability-based SPN

(a) Result for query S2.3.

0 2500 5000 7500 10000number of samples

0.04

0.06

0.08

0.10

aver

age

rela

tive

erro

r

0 2500 5000 7500 10000number of samples

0.2

0.4

0.6

0.8

1.0

bin

com

plet

enes

s

(b) Result for query S2.4.

Figure 9: Results of the sample-based approaches on the synthetic datasetwith respect to the number of generated samples.

and the y-axis represents the relative error of the approximation.For clarity, we have visualized the result of the probability-basedapproach as a horizontal line in the plots.

Compared to random sampling, we can observe in the plotsthat we are able to achieve good results with the relevance sam-pling approach after obtaining only a few samples. As afore-mentioned, the quality of the approximations of our proposedapproaches mainly depend on the quality of the SPN. Therefore,the result of the relevance sampling approach always convergesto the result of the probability-based approach and does not im-prove with more samples. This is clearly visible for the highselectivity query displayed in Figure 8a in which random sam-pling outperforms the SPN approaches with increasing numberof samples. However, the results of the low selectivity queriesdemonstrate the advantage of relevance sampling. In fact, therelevance sampling approach is independent of the selectivityof the query because it does not discard any samples, but thequality of the approximations is bounded to the quality of theSPN.

7.5 Exp. 4: Effect of SkewnessWith the same setting as for the previous experiment, we exam-ine the skewness of the grouping on our proposed approaches.Therefore, we now include the stratified sampling approach andevaluate the queries S1 and S2 on the synthetic dataset.

The first and foremost observation on all queries is that therelevance and the stratified sampling approach are able to obtainbetter results with fewer samples compared to random sampling.The reason for this behaviour is that the biased sampling ap-proaches are able to use all the generated samples while therandom sampling approaches have to discard approximately 75%of the generated samples due to the selectivity of the queries.

Figure 9 visualizes our results examplarily for the queriesS2.3 and S2.4. The x-axis represents the generated number ofsamples and the y-axis represents the value for average relativeerror or the bin completeness. The result of the probability-basedapproach is visualized as a horizontal line in the plots.

In the plots, we can observe that the stratified sampling ap-proach instantaneously reaches full bin completeness irrespec-tive of the skewness of the SQL-query. In contrast, the randomsampling approaches and even the relevance sampling approach

require a considerable amount of samples to provide approxima-tions for all the groups. The fact that random sampling obtains arespectable good average relative error on query S2.4 is causedby the low bin completeness since the missing approximationsfor the low selectivity are not considered by this measure.

7.6 Exp. 5: Effect of Model QualityAs already stated in the previous experiments, the quality of theapproximations of our proposed AQP approaches depend on thequality of the SPN. The quality of an SPN is mainly defined by theparameters for the construction. Hence, we examine the effect ofthe parameter configuration for the construction of the SPN onthe quality of the approximations in this experiment. We havechosen to use the synthetic and the flights1M dataset on whichwe evaluated all queries with the probability-based approach.For the hyper-parameter configuration of the SPN, we varied therdc-threshold as well as the min instance slice (for explanation ofthe parameters we refer to [17]).

The first observation on the results of the dataset flights1M isthat the different hyper-parameter settings for the constructionof the SPN has only minor influence on the quality of the ap-proximations. Regarding the most general SPN, which assumesindependence on all columns, the quality of the SPN does notimprove with more precise parameter settings. In contrast, onthe synthetic dataset the parameter settings have a major in-fluence on the quality of the computed approximations. Theimprovement of average relative error for queries S3 and S4 ofthe synthetic dataset are displayed in Table 6.

A closer examination of the results reveals that the relativeerror among the queries increases for a smaller sub-populationon which the query is applied. In particular, for the queries S3.1to S3.4 this observation is clearly visible. As already investigatedin the first experiment, the reason is that the computation forgroups with only a few instances is more error prone than forgroups with more instances. This explains the fact that querieson very rare sub-populations result in a higher average relativeerror. However, we are interested in why these approximationsare likely to yield a higher relative error.

Taking a closer look at the results of all queries, we recognizethat this behavior only applies for the queries with COUNT andSUM aggregations. Since these aggregations need to be scaled

100 101 102 103 104

number of instances

40

20

0

20

40

actu

al d

iffer

ence

(a) Absolute difference.

100 101 102 103 104

number of instances

0

1

2

3

4

rela

tive

diffe

renc

e

(b) Relative difference.

Figure 10: Difference between the actual amount of in-stances in the dataset flights1M and the computed amountof instances with SPN for all groups of all queries.

up in order to obtain the approximation, they rely on the com-putation of inference for the query which may be the cause forthe error. Hence, we have analyzed the result of the inferencecomputation in more detail on the dataset flights1M. In particular,we have used the SPN to estimate the number of instances ofthe sub-population for each group of the queries and set it intorelation with the actual number of instances for the respectivegroup in the actual dataset. On the one hand, we have visual-ized the absolute difference which can be seen in Figure 10a and,on the other hand, we have visualized the relative difference inFigure 10b. For both plots the x-axis represents the number ofinstances for the group in the actual dataset whereas the y-axisrepresents the (relative) difference of the estimated number ofinstances. A positive value for the y-axis implies that the SPNhas overestimated the number of instances for a particular groupwhile a negative values implies that the number of instances hasbeen underestimated.

In Figure 10a we can observe that the computed number ofinstances with the SPN is actually very accurate for groups whichcontain only a few instances. In contrast, the groups containingmore instances have a bigger error in the estimated number ofinstances. However, since we are dealing with the relative error,we have to examine the relative difference which is displayed inFigure 10b. Here, we can observe that the relative difference ismuch higher for the groups which rely on only a few instances.Furthermore, the extent of the relative difference decreases withincreasing size of the group even though the actual difference ofthe estimation gets bigger. Therefore, we can conclude that thehigh relative error is mainly caused by the high relative differencein the approximation for the number of instances for very smallsub-populations. Moreover, this observation also explains thegood results on query F3.3 and queries S4.1 to S4.4 because for theapproximation of anAVG aggregation, we do not have to computethe size of the sub-population with the SPN and, therefore, wedo not have this bias in our approximation.

This suggests that we can use the SPN to get a certainty aboutthe approximated result. In particular, the SPN can be used toevaluate the quality for the approximation of a SQL query with-out accessing the actual data. We have to obtain the number ofinstances for the groups. In case that only a few instances areavailable for a specific group, we can conclude that the resultmay not be very precise. In contrast, we can be more certainabout the approximation if the group contains more instances.

With the increase of the size of the SPN, we can observe thatthe runtime for the probability-based approach increases as well.Taking the scalability experiment into account, we can concludethat the execution time highly depends on the size of the SPNwhile the size of the dataset has only minor impact. Apart from

the size of the SPN, we can see that the queries which rely onmany columns have a significantly higher runtime than querieswhich are only applied on a few columns. The reason for thisbehavior is that the SPN is marginalized beforehand to the setof relevant columns. Due to the marginalization inference andexpectation is computed a smaller SPN which saves a lot of com-putation time. Since the runtime of the proposed AQP techniquesmatters, we have to choose a parameter configuration for theconstruction of the SPN which ensures that the size of the SPNdoes not grow to big and that the data is represented precisely.Our evaluation of different parameter settings has shown thatthe SPN can grow very big with a very precise parameter settings.However, this is not ideal because the runtime of the proposedAQP techniques increases rapidly. Thus, we have to find a trade-off between the accurateness and the size of the SPN.

8 RELATEDWORKApproximate query processing (AQP) emerged from the need toreduce the response time of queries executed on huge amountsof data. AQP gained more and more interest due to the techno-logical advancements and cheap storage cost of data. Especiallyin recent years a lot of research took place in this field [15]. Ingeneral, the primary focus of AQP techniques is the approxi-mation of aggregation queries whereby COUNT, AVG and SUMaggregations are the most popular. Ideally, the AQP approach cansupport all kinds of aggregation queries [6, 18] including joinsand nested queries. Moreover, no assumptions about the datashould be made in advance and the approximation of a queryresult should be a magnitude faster than executing the query onthe whole table [18].

AQP techniques belong to one of the following two categories:(1) Sample-based approaches and (2) approaches which rely on apre-computed synopsis. For sample-based approaches, we canfurther differentiate between unbiased (e.g. random sampling)and biased sampling (e.g., stratified sampling). Biased samplingapproaches like BlinkDB [2] or dynamic sample selection [3]can provide fast approximations over rare sub-populations in anefficient manner but need to maintain a set of selected samples inmemory. In general, such sets of samples cannot be computed inadvance since no prior knowledge about the workload is given [2,6]. This problem is solved by obtaining the samples during querytime [12]. Most of the sample-based approaches, in particular theunbiased sampling techniques, are applied during query time onthe fly which is referred as online aggregation. Systems for onlineaggregation which rely on unbiased samples, like CONTROL [11]or DBO [13], typically provide good approximations for queriesover the mass of the distribution but cannot provide fast answersfor queries on rare sub-populations [6]. The original work foronline aggregation considered only queries on one table whilefollow-up work extended the techniques also for queries withjoins [9, 14].

The difference between these approaches and our model-basedAQP is as follows: Generally, in the classical AQP approachesprior knowledge about the workload is required in advance, togenerate a set of biased samples. However, especially for interac-tive data exploration the queries are not known in advance, forwhich reason these samples are obtained during query time [2, 6].Different from those approaches, model-based AQP can producebiased samples on-the-fly and thus supports ad-hoc queries overrare sub-populations.

Moreover, there are AQP approaches which construct a synop-sis of the data in advance [7]. For example, such data structurescan be materialized views or data cubes [8]. Nevertheless, anyother data structure can be used for the synopsis if can provideanswers for aggregation queries. In general, approaches whichrely on synopsis usually lack the ability to support all possibleSQL-queries since they have abstracted the entries of the table.The most famous online analytic processing tool is OLAP [4]for which a data cube is constructed by defining hierarchiesover the dimensions. Using this data cube, aggregation queriesover these hierarchical dimensions can be answered efficiently.However, OLAP provides poor performance for queries on raresub-populations [2] and the computation of the cube can takesignificant processing time [12].

9 CONCLUSION AND FUTUREWORKIn this work, we have proposed a new approach for AQP usinggenerative models. With our proposed approach, we are able toovercome major problems of classical AQP approaches. In ourexperimental evaluation, we have shown that the accuracy ofthe approximations of our model-based approaches outperformclassical AQP approaches on real and synthetic data sets. Further-more, the runtime of our proposed approaches mainly dependson the size of the constructed SPN and not on the data set sizemaking them an ideal candidate for exploring large data sets.

For future work, it remains to analyze the behavior of theproposed approaches on other datasets. In particular, the modelquality of the constructed SPNs needs to be examined in moredetail. In addition, the quality of the SPNs for AQP could befurther improved. In future we want to introduce SPNs that area hybrid of the data and the model and keep the original data ifhigh correlations between attributes are detected. By doing this,we can avoid losing particular correlations among the data forsub-populations which are difficult to separate. More precisely,we avoid creating product nodes which introduce a major errorinto the SPN. Furthermore, we have proposed a way to computeconfidence bounds with the SPN and a way how disjunctiveconditions among different columns can be handled. Finally, infuture we plan to also support more complex queries includingjoins and nested queries. The general idea is to construct a SPNfor each table individually and to combine the approximationsof the different SPNs during query runtime.

REFERENCES[1] S. Acharya, P. B. Gibbons, V. Poosala, and S. Ramaswamy. The Aqua Approx-

imate Query Answering System. In Proceedings of the 1999 ACM SIGMODInternational Conference on Management of Data, pages 574–576, 1999.

[2] S. Agarwal, B. Mozafari, A. Panda, H. Milner, S. Madden, and I. Stoica. BlinkDB:Queries with Bounded Errors and Bounded Response Times on Very LargeData. In Proceedings of the 8th ACM European Conference on Computer Systems,pages 29–42, 2013.

[3] B. Babcock, S. Chaudhuri, and G. Das. Dynamic Sample Selection for Approxi-mate Query Processing. In Proceedings of the 2003 ACM SIGMOD InternationalConference on Management of Data, pages 539–550, 2003.

[4] S. Chaudhuri and U. Dayal. An Overview of Data Warehousing and OLAPTechnology. ACM SIGMOD Record, 26(1):65–74, March 1997.

[5] P. Eichmann, C. Binnig, T. Kraska, and E. Zgraggen. IDEBench: A Benchmarkfor Interactive Data Exploration. In Proceedings of the Very Large Data BaseEndowment, volume 11, 2018.

[6] A. Galakatos, A. Crotty, E. Zgraggen, C. Binnig, and T. Kraska. RevisitingReuse for Approximate Query Processing. Proceedings of the Very Large DataBases Endowment, 10(10):1142–1153, June 2017.

[7] M. N. Garofalakis and P. B. Gibbons. Approximate query processing: Tamingthe terabytes. In VLDB 2001, Proceedings of 27th International Conference onVery Large Data Bases, September 11-14, 2001, Roma, Italy, 2001.

[8] J. Gray, S. Chaudhuri, A. Bosworth, A. Layman, D. Reichart, M. Venkatrao,F. Pellow, and H. Pirahesh. Data Cube: A Relational Aggregation Operator Gen-eralizing Group-By, Cross-Tab, and Sub-Totals. Data Mining and Knowledge

Discovery, 1(1):29–53, March 1997.[9] P. J. Haas and J. M. Hellerstein. Ripple Joins for Online Aggregation. In

Proceedings of the 1999 ACM SIGMOD International Conference on Managementof Data, pages 287–298, 1999.

[10] P. Hanrahan. Analytic database technologies for a new kind of user: The dataenthusiast. In Proceedings of the 2012 ACM SIGMOD International Conferenceon Management of Data, SIGMOD ’12, pages 577–578, New York, NY, USA,2012. ACM.

[11] J. M. Hellerstein, R. Avnur, A. Chou, C. Hidber, C. Olston, V. Raman, T. Roth,and P. J. Haas. Interactive Data Analysis: the Control Project. Computer,32(8):51–59, August 1999.

[12] J. M. Hellerstein, P. J. Haas, and H. J. Wang. Online Aggregation. In Proceedingsof the 1997 ACM SIGMOD International Conference on Management of Data,pages 171–182, 1997.

[13] C. Jermaine, S. Arumugam, A. Pol, and A. Dobra. Scalable Approximate QueryProcessing with the DBO Engine. ACM Transactions on Database Systems,33(4):23:1–23:54, December 2008.

[14] F. Li, B. Wu, K. Yi, and Z. Zhao. Wander Join: Online Aggregation via RandomWalks. In Proceedings of the 2016 International Conference on Management ofData, pages 615–629, 2016.

[15] Q. Liu. Approximate Query Processing. In Encyclopedia of Database Systems,2009.

[16] Z. Liu et al. The Effects of Interactive Latency on Exploratory Visual Analysis.Visualization and Computer Graphics, IEEE Transactions on, 20(12):2122–2131,2014.

[17] A. Molina, A. Vergari, N. D. Mauro, S. Natarajan, F. Esposito, and K. Kersting.Mixed Sum-Product Networks: A Deep Architecture for Hybrid Domains. InAAAI, 2018.

[18] Y. Park, A. S. Tajik, M. Cafarella, and B. Mozafari. Database Learning: Towarda Database That Becomes Smarter Every Time. In Proceedings of the 2017 ACMInternational Conference on Management of Data, pages 587–602, 2017.

[19] H. Poon and P. Domingos. Sum-product networks: A New Deep Architecture.In 2011 IEEE International Conference on Computer Vision Workshops, pages689–690, November 2011.

[20] C. Stolte et al. Polaris: a system for query, analysis, and visualization ofmultidimensional relational databases. Visualization and Computer Graphics,IEEE Transactions on, 8(1):52–65, 2002.

APPENDIX

Listing 2: Queries for the dataset flights.F 1 . 1 SELECT AVG( dep_de l ay ) FROM f l i g h t s WHERE o r i g i n = 'ATL 'F 1 . 2 SELECT AVG( d i s t a n c e ) FROM f l i g h t s WHERE un i q u e _ c a r r i e r = 'TW 'F 2 . 1 SELECT un i q u e _ c a r r i e r , COUNT ( ∗ ) FROM f l i g h t s

WHERE o r i g i n _ s t a t e _ a b r = 'LA ' GROUP BY un i q u e _ c a r r i e rF 2 . 2 SELECT un i q u e _ c a r r i e r , COUNT ( ∗ ) FROM f l i g h t s

WHERE o r i g i n _ s t a t e _ a b r = 'LA ' AND d e s t _ s t a t e _ a b r = 'CA 'GROUP BY un i q u e _ c a r r i e r

F 2 . 3 SELECT yea r_da t e , COUNT ( ∗ ) FROM f l i g h t sWHERE o r i g i n _ s t a t e _ a b r = 'LA ' AND d e s t = ' JFK 'GROUP BY yea r _da t e

F 3 . 1 SELECT yea r_da t e , SUM( d i s t a n c e ) FROM f l i g h t sWHERE un i q u e _ c a r r i e r = ' 9E 'GROUP BY yea r _da t e

F 3 . 2 SELECT o r i g i n _ s t a t e _ a b r , SUM( a i r _ t im e ) FROM f l i g h t sWHERE d e s t = 'HPN ' GROUP BY o r i g i n _ s t a t e _ a b r

F 3 . 3 SELECT un i q u e _ c a r r i e r , AVG( dep_de l ay ) FROM f l i g h t sWHERE yea r _da t e = ' 2005 ' AND o r i g i n = 'PHX 'GROUP BY un i q u e _ c a r r i e r

F 4 . 1 SELECT d e s t _ s t a t e _ a b r , COUNT ( ∗ ) FROM f l i g h t sWHERE d i s t a n c e >2500 GROUP BY d e s t _ s t a t e _ a b r

F 4 . 2 SELECT un i q u e _ c a r r i e r , COUNT ( ∗ ) FROM f l i g h t sWHERE a i r _ t ime >1000 AND dep_de lay >1500GROUP BY un i q u e _ c a r r i e r

Listing 3: Queries for the synthetic dataset.S 1 . 1 SELECT A, COUNT ( ∗ ) FROM syn WHERE f i l t e r = ' 1 ' GROUP BY AS 1 . 2 SELECT A, COUNT ( ∗ ) FROM syn WHERE f i l t e r = ' 2 ' GROUP BY AS 1 . 3 SELECT A, COUNT ( ∗ ) FROM syn WHERE f i l t e r = ' 3 ' GROUP BY AS 1 . 4 SELECT A, COUNT ( ∗ ) FROM syn WHERE f i l t e r = ' 4 ' GROUP BY AS 2 . 1 SELECT A, AVG( B ) FROM syn WHERE f i l t e r = ' 1 ' GROUP BY AS 2 . 2 SELECT A, AVG( B ) FROM syn WHERE f i l t e r = ' 2 ' GROUP BY AS 2 . 3 SELECT A, AVG( B ) FROM syn WHERE f i l t e r = ' 3 ' GROUP BY AS 2 . 4 SELECT A, AVG( B ) FROM syn WHERE f i l t e r = ' 4 ' GROUP BY AS 3 . 1 SELECT COUNT ( ∗ ) FROM syn WHERE f i l t e r = ' 1 ' AND A= ' 4 'S 3 . 2 SELECT COUNT ( ∗ ) FROM syn WHERE f i l t e r = ' 2 ' AND A= ' 4 'S 3 . 3 SELECT COUNT ( ∗ ) FROM syn WHERE f i l t e r = ' 3 ' AND A= ' 4 'S 3 . 4 SELECT COUNT ( ∗ ) FROM syn WHERE f i l t e r = ' 4 ' AND A= ' 4 'S 4 . 1 SELECT AVG( B ) FROM syn WHERE f i l t e r = ' 1 ' AND A= ' 4 'S 4 . 2 SELECT AVG( B ) FROM syn WHERE f i l t e r = ' 2 ' AND A= ' 4 'S 4 . 3 SELECT AVG( B ) FROM syn WHERE f i l t e r = ' 3 ' AND A= ' 4 'S 4 . 4 SELECT AVG( B ) FROM syn WHERE f i l t e r = ' 4 ' AND A= ' 4 '