Leveraging Soft Functional Dependencies for IndexingMulti-dimensional Data

Behzad GhaffariImperial College London

bg916@imperial.ac.uk

Ali HadianImperial College London

hadian@imperial.ac.uk

Thomas HeinisImperial College London

t.heinis@imperial.ac.uk

ABSTRACTRecent work proposed learned index structures, which learnthe distribution of the underlying dataset to improve theirperformance. The initial work on learned indexes has re-peatedly shown that by learning the cumulative distributionfunction of the data, index structures such as the B-Tree canimprove their performance by an order of magnitude whilehaving a smaller memory footprint.

We propose a new learned index for multidimensional datathat instead of learning the distribution of keys, learns fromcorrelations between columns of the dataset. Our approachis driven by the observation that in many datasets, the val-ues of two (or multiple) columns are correlated. Databasestraditionally already exploit correlation between the columnsand more specifically soft functional dependencies (FDs) inquery optimisers to predict the selectivity of queries andthus to find better query plans. We want to take the learnedfunctional dependencies a step further and use them to cre-ate more efficient indexes. In this paper, we consequentlyuse learned functional dependencies to reduce the dimen-sionality of the datasets. With this we attempt to workaround the curse of dimensionality — which in the contextof spatial data stipulates that with every additional dimen-sion, the performance of an index deteriorates further — toaccelerate query execution.

More precisely, we learn how to infer one (or multiple)attributes from the remaining attributes and hence no longerneed to index it. This reduces the dimensionality and hencemakes the index more efficient. We show experimentallythat by predicting correlated attributes in the data, ratherthan indexing them, we can improve the query executiontime and reduce the memory overhead of the index at thesame time. In our experiments, we are able to reduce theexecution time by 25% while shrinking the memory footprintof the index by four orders of magnitude.

PVLDB Reference Format:Behzad Ghaffari, Ali Hadian, Thomas Heinis. Leveraging SoftFunctional Dependencies for Indexing Multi-dimensional Data.PVLDB, 09(xxx): xxxx-yyyy, 2020.

This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License. To view a copyof this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/. Forany use beyond those covered by this license, obtain permission by emailinginfo@vldb.org. Copyright is held by the owner/author(s). Publication rightslicensed to the VLDB Endowment.Proceedings of the VLDB Endowment, Vol. 09, No. xxxISSN 2150-8097.DOI: https://doi.org/10.14778/xxxxxxx.xxxxxxx

DOI: https://doi.org/10.14778/xxxxxxx.xxxxxxx

1. INTRODUCTIONMultidimensional data plays a crucial role in many dif-

ferent applications, be it in spatial data analytics or dataanalytics in general. Indexing multidimensional data, how-ever, is challenging as the curse of dimensionality hits: withevery additional dimension indexed, performance of the in-dex degrades. Therefore, multidimensional data calls fornovel approaches in modelling and indexing large spatialdata. A promising approach to tackle the curse of dimen-sionality is using machine learning techniques and exploitpatterns in data distribution for more efficient indexing.For example, learned indexes automatically model and usethe distribution of the underlying data to find locate thedata records [11, 4, 13, 9, 14, 3, 6, 10, 8], and the ideahas recently been extended to indexing multidimensionaldata [14]. Recent work for learned indexes, however, pri-marily approaches the challenge by learning from the Cu-mulative Distribution Function (CDF) of the dataset.

In this paper we develop a new class of learned indexesfor multidimensional data that uses dependencies betweenattributes of either the full or a subset of the dataset to im-prove performance of the index structure. Our approach ismotivated by the observation that in real datasets, correla-tion between two or more attributes of the data is a commonoccurrence. We argue that by taking learned indexes to themultidimensional case, in addition to learning from CDF ofthe data, we also have the opportunity to learn from rela-tionships between attributes of the data such as correlationbetween id and timestamp, a common case in real-worlddatasets; or between flight distance and flight time in an air-line dataset, which is derived from physical phenomenons.The idea of learning from attributes, i.e., learning the rela-tionship between columns of data, has already been used toimprove estimate the selectivity of a given query and thusto improve query optimisers [7]. We take this idea a stepfurther to indexing multidimensional data.

More precisely, we develop models that explain correla-tions in the attributes of the data and we show that weconsequently do not need to index every dimension, therebyeffectively reducing the dimensionality of the dataset. Weonly need to store one dimension for each group of corre-lated attributes. In case a query with a ”missing” dimen-sion is executed, we use our model to check which range ofvalues in the indexed dimensions correlate with the queryand scan the indexed attribute instead. As we show exper-imentally, the suggested approach significantly shrinks the

1

arX

iv:2

006.

1639

3v1

[cs

.DB

] 2

9 Ju

n 20

20

QueryLearned Grid

Index

SecondaryIndex

Merged output

Figure 1: Overview of the suggested index structure: A primary index (top) indexes only one dimension from each group ofcorrelated attributes, while a secondary index handles the outliers and guarantees the retrieval of all results

memory footprint of the index, by 1.5 to 5 orders of magni-tudes depending on the number of the FDs and their degreeof correlation, while improving the overall lookup time ofthe indexes at the same time.

The remainder of the paper is structured as follows. Wefirst discuss related work in section 2, and then provide anoverview of our approach in section 3. Further we discusshow to detect, model, and index the correlated attributesin section 4. In section 7 we discuss our experimental setupand, more importantly, the experimental results. We finallyconclude the paper in 8 where we also discuss future work.

2. RELATED WORKThe ideas in this paper build upon various research di-

rections including learned data structures, partial indexes,model estimation, interpolation search and grid-based datastructures.

We refer to the paper by Kraska et al. [11] which first in-troduced and explored the idea of the learned index. In alearned index, the CDF of the key distribution is learned byfitting a model; then the learned model is used as a replace-ment to the conventional index structures (such as B+tree)for finding the physical location of the query results. In-dex learning frameworks such as the RMI model [11, 13] arecapable of learning arbitrary models [13], though further re-search and a recent experimental benchmark [8] has shownthat simple models such as linear splines are very effectivefor most real-world datasets [4, 9, 12, 6].

Our work is partially inspired by hybrid learned indexesthat combine machine learning with traditional indexes struc-tures [8, 4, 6, 12]. Hybrid learned indexes have recently beenwell explored in the one-dimensional case. For example,RadixSpline [8] uses radix-trees as the top-level model whileFITing-tree [4] and IFB-tree [6] use B+tree as the top-levelindex structure. Then they use a series of piecewise lin-ear functions in the leaf level. Such a model-assisted indexdesign limits the worst case inefficiencies of the model. Fur-thermore, adaptability and updatability of learned indexeshave been explored in a similar area [3, 5]. Finally, in themultivariate area, learning from a sample workload has alsoshown interesting results [14].

Despite focusing on different problems, our work is par-ticularly inspired by FITing-tree, which uses a fraction ofkeys rather than the full key set to build the index. It thenmakes up for the reduced accuracy of the index by predict-ing any key’s position that is not indexed. This prediction

is achieved using piecewise linear functions that are respon-sible for interpolation for different sections of data. TheFITing-Trees, maintains a minimum and maximum errorterm for its models that are updated on inserts.

3. APPROACH OVERVIEWAs outlined previously, we are interested in exploiting cor-

relations in a multidimensional dataset to build a more effi-cient index. Therefore, the structure of the key steps of ourapproach, illustrated in Figure 1, are as follows:

• Learning the correlations. We first implement amethod that automatically detects whether a func-tional dependency exists between two or more columns,and evaluates whether the dependency can be effec-tively modelled in the presence of noise.

• Primary index. We then apply a pre-processing stepto our data. We use the learned correlations to sepa-rate data that agree with the learned dependency fromthe remaining points that are regarded as outliers. Wewill create a primary index on those data points thathave up to a certain deviation from the learned cor-relation (i.e. those that are within a certain tolerancemargin around the fitted line). The primary index onlyindexes one column per each set of correlated columns.For the rest of the correlated columns, a model islearned to represent the correlation between indexedattributes and learned attributes will be used to exe-cute queries. If a query targets a dependent columnCd that is not indexed but is correlated with anotherindexed column Ci, then the learned correlation modelautomatically converts the query constraints targetingCd to an equivalent constraint on Ci.

• Secondary index. Data points that do not fall withinthe tolerance margin of the soft FD model are ex-cluded from the primary index and are indexed withall dimensions in a secondary index, which is a typicalmultidimensional index structure like R-tree or Gridindex.

• Query translation. As the data in the primary indexis now highly correlated, we define a model to predictany correlated dimensions in the data i.e. we predictlearned attributes using the set of indexed attributes.By doing so, we show that an index on the key, in-formative dimensions along with a learned model that

2

Figure 2: An error margin can be defined by considering thethe correlation model of the data (left) and the density ofthe data points around the model (right)

predicts remaining indexed dimensions can achieve upto 25% better execution performance while reducingthe index size by an order of 10,000X.

4. DEPENDENCY DETECTIONLearned index structures — and indexes in general —

typically work by predicting where a queried record might belocated in storage space and scan near the prediction to findany matching results. Because of this, models used by anindex structure must be able to achieve sufficient accuracy inpredicting every point that is indexed, otherwise a lookupmight take an unexpected amount of time to execute. Inthe context of this paper, it means that when looking forcorrelations, our goal is not to find a model that minimisesthe distance to every point in the dataset. Rather, we areinterested in a model that is sufficiently close to a sizeableportion of data points. Put differently, we must pick anysufficiently large subset of all points in our dataset and finda model that best explains these points while ignoring theremaining points, i.e., the outliers. We also aim to keep theprocess of learning models as efficient as possible to avoidsignificant retraining delays in the case that our model losesits accuracy after a high number of inserts.

Motivated by minimising the training time and error inour model, the main contribution in our method for detect-ing correlation is that we only consider centres of dense ar-eas in a sample drawn from the dataset. More precisely, weoverlay a multidimensional grid on the key space (spanningminimum and maximum points along each dimension) andmeasure the weight of each cell (bucket) by counting thenumber of points that intersect with the cell. We then filterout any cells that do not reach a threshold in their weightsand consider our training data to be the weighted centres ofthe remaining cells. This approach is similar to observinga heat map and deciding where a correlation can be seen.Figure 2 shows the heatmap of a pair of correlated columns,together with the buckets’ centres that reach the minimumthreshold.

After the training set (bucket centres) is found, in orderto learn correlations between multiple attributes, we recur-sively consider unique pairs of columns and attempt to usea Monte Carlo sampler to check whether a linear model fitsthe training points (Algorithm 1). If two columns are foundto be correlated, we save the resulting pair along with theirmodel parameters. In the final step we merge all groupsthat have a dimension in common and pick one column ineach group to be the predictor responsible for estimating theremaining columns in its group (or context in alternativeterminology). Later in section 5 we show how the predic-tor columns can be used to reduce the dimensionality of an

Algorithm 1: Splitting Data

Input: Centred column values: C1, C2 [N ]Result: Model parameters (m, b) and (primary index,secondary index)C1 sample = C1.sample(sample count)C2 sample = C2.sample(sample count)w1 = C1 sample.max() / bucket chunksw2 = C2 sample.max() / bucket chunksbuckets = [bucket chunks][bucket chunks]for i← 0 to sample count do

buckets[C1[i] / w1][C2[i] / w2] += 1endC1 train = C2 train = []for i← 0 to bucket chunks do

for j ← 0 to bucket chunks doif buckets[i][j] > threshold then

C1 train += [i * w1 + 0.5w1] * buckets[i][j]C2 train += [j * w2 + 0.5w2] * buckets[i][j]

end

end

endm, b = linear regress(C1 train, C2 train)

displacements = ((C2 - b - m * C1)) /√

(1 +m2)for i← 0 to N do

if displacements[i] >displacements.quantile(lower) anddisplacements[i] < displacements.quantile(upper)thenprimary index.insert(C1[i], C2[i])

elsesecondary index.insert(C1[i], C2[i])

end

end

index while allowing queries on all columns.Parameters. The suggested method leaves a few param-

eters that can be tuned to boost performance. For example,we can use larger samples in combination with smaller buck-ets and a lower bucket acceptance threshold to increase ourmodels’ accuracy. We will leave tuning these parameters asfuture work.

5. PREDICTING DEPENDENT ATTRIBUTESLet us consider the simple case where we want to an-

swer queries on two columns C1 and C2. We define aquery by a rectangle characterised by its lowermost left-most point (q1low, q2low) and uppermost rightmost point(q1high, q2high). Note that with this setting, we can ex-press the case where, for example, only the first dimensionis queried by defining q2high = ∞ and q2low = −∞. Sim-ilarly we can express point queries by defining the lowerand upper points to be equal. With this we only need toimplement a search strategy for the full query, i.e., where(q1low, q2low) and (q1high, q2high) are defined and unequal,to cover all cases.

Suppose that the columns to be indexed (C1 and C2) arecorrelated, i.e., a soft functional dependency between C1and C2 can be learned. In this case, an range index canbe built on only one of the attributes, and any query con-straint that target a non-indexed attribute can be mappedto equivalent query constraints on the indexed column using

3

the prediction model and its error bounds. To do this with-out loss in accuracy, we need to define an oracle functionψ : C1 → C2 that calculates the exact value of C2 basedon a given C1 for each row in the dataset. Because in prac-tice finding such an oracle function may prove impossiblefor real-world datasets, we must relax this concept and al-low our model to instead predict the approximate value forC2.

As in the case with other approaches in learned indexstructures [11, 3, 10], using an approximation without anybounds is impractical since we want to avoid scanning theentire dataset when only the learned dimension is queried.We must therefore define tight error bounds for the approx-imation. To do so, we argue that once a significant majorityof the values of the learned attribute C2 are learned, i.e.,the corresponding data points are located along a line, wecan define a margin (minimum and maximum error bounds)thus characterising a distribution close to a straight line. Wethen only keep the points that fall between these bounds andleave outliers aside to be inserted into a secondary partialindex. Put differently, for any point (p1, p2) ∈ (C1, C2) inour primary index we have:

p2 ∈ [ψ(p1)− emin, ψ(p1) + emax] (1)

Where emin, emax are the error bounds, or as illustratedgraphically, the distances at which the data separators havebeen drawn on both directions. Figure 1 shows the process ofdefining the two parallel lines characterising the minimumand maximum error bounds and the role of our primaryand secondary index. Reiterating that these maximum errorterms are small enough, when asked to create a multidimen-sional index on C1 and C2, we only need to sort our rowsbased on the C2 column and argue that the other dimensionwas not informative enough. To answer a range query tar-geting both dimensions, we will need to (1) calculate whichrange of positions in the indexed dimension correspond tothe queried range for the missing dimension and (2) scanthe intersection of the the queried ranges projected on theindexed dimension.

Put differently, because the data in the primary index isnow perfectly linear, we will be able to immediately tightenthe minimum and maximum bounds of our query for eachof correlated dimensions making the overall scanned rangesmaller. As illustrated in Figure 3 with a 2D example, weneed to find the intersection points of the query rectanglewith our minimum and maximum thresholds. We can thenscan the points in the indexed attribute (C2) between themore selective bounds (drawn as solid vertical lines in Figure3):

[max(ψ(q1low), q2low−emin), min(ψ(q1high), q2high+emax)](2)

6. INDEX LAYOUTIn order to evaluate differences in performance when pre-

dicting dimensions, we need to build an index on indexed di-mensions. We implement our index on top of Grid Files [15]with a few modifications. In particular we choose bound-aries for each cell based on quantiles along each dimensionand use the same number of grid lines for each attribute.Addresses for all cells are sorted using the original order-ing of columns in the dataset. Furthermore, each cell stores

Figure 3: Query execution in the primary index. Queryconstraints targeting the dependent columns (constraints onthe y-axis of the query box) are mapped to equivalent con-straints on the indexed column using the correlation modeland the error bounds (tolerance margin). The final queryconstraint is the intersection of the two constraints (verticallines)

0 5000 10000 15000 20000page length

0

500

1000

1500

2000

coun

t

(a) Non-uniform distribution of page sizes in 2D grid layout

(b) 2D Index Layout (c) Learned 1D Grid

Figure 4: Reduced index dimensionality means we can affordmore accurate grids for the remaining predictor dimensions

points in a continuous block of virtual memory in a row storeformat. Finally, rows within each page are sorted based ona given function similar to the approach proposed in Flood[14]. Sorting the rows inside pages means that we can reducethe dimensionality of the grid by one. This is because in-stead of having grid lines for the particular sorted attributewe can use binary search to locate items (or a scan betweentwo bounding binary searches in a range query).

Note that picking grid lines based on distribution of thedataset does not mean that we have regular cells. Althoughdoing so does reduce the standard deviation in cell lengthsfor non uniform datasets, bucket lengths are still allowed togrow arbitrarily large. Figure ?? shows the variation in celllengths in one of our experiments.

The combination of predicting attributes and having asorted dimension means that for a dataset with n dimensionsand m predicted attributes, we only need an index withn −m − 1 dimensions. Due to this reduced dimensionalitywe will show in section 7.2.4 that the resulting index makesmuch more efficient use of memory. Such an effect is also

4

Airline OSM

Count 80M 105M

Key Type float float

Dimensions 8 4

Correlated Dimensions (3, 3) 2

Indexed Dimensions (Learned) 2-4 3

Primary Index Ratio 92% 73%

Table 1: Dataset characteristics

illustrated in Figure 4.

7. EVALUATION

7.1 Experimental Setup

7.1.1 Implementation and Runtime EnvironmentWe implement the online section of our index in C and

compile it using Clang 10.0.0. All of the mentioned indexesin our experiments including the R-Tree and Grids run in asingle thread and use single precision floating point values.For the offline data processing sections, we use Python andthe pymc3 library [2] for model estimations. We run ourmeasurements on a machine with Intel Core i5-8210Y CPUrunning at 3.6 GHz (L1: 128KB, L2: 512KB, L3: 4MB) and8GB of RAM.

7.1.2 DatasetsWe run our experiments on two real world datasets:Open Street Map (OSM): we use 4 dimensions of the OSM

data for the US Northeast region [1] which contains 105Mrecords; The Id and T imestamp attributes in the OSMdataset are correlated and its Latitude and Longitude co-ordinates contain multiple dense areas. For this dataset wegroup (Id, T imestamp) for the case of learned index.

Airlines: data from US Airlines flights from 2000 up to2009, which has 8 attributes and 80M records. The air-line dataset is more interesting for our experiments becauseit contains many correlated dimensions. Example group-ing in this dataset in our experiments usually consists of(Distance, T imeElapsed, AirT ime) and (ArrT ime, DepT ime,ScheduledArrT ime). We can reduce the grid dimensional-ity to 2-4 in the case of the learned grid. Table 1 summarisesthe key aspects of the datasets.

We generate the queries by picking a random point fromthe data. Then, we look at knn nearby points and takethe minimum and maximum values corresponding to eachdimension. Our range queries are rectangles and target allcolumns in the index. Figure 5 shows the distribution of theresult count in our query set.

7.1.3 BaselinesWe refer to our implementation explained throughout this

paper as the Learned grid. We compare our suggested methodwith R-Tree, arguably the most broadly used index for mul-tidimensional data, and two grid structures as baselines: theuniform grid and column files.

Uniform grid : or equivalently the full grid, is a hash struc-ture that breaks down each attribute into uniformly sized

0 20000 40000 60000number of matched items

0

5

10

15

query co

unt

Figure 5: Example distribution of query selectivity in Airlinedata

grid cells between their minimum and maximum values. Theaddress for each cell is stored independently and no adjacentcells are ”shared/merged” explicitly. In memory, addressesfor all cells are sorted using the original ordering of columnsin the dataset. Furthermore, each cell stores points in acontinuous block of virtual memory in a row store format.

Column files: Essentially a non uniform grid, uses theCDF of the data to align/arrange its cell boundaries andsorts data within each cell based on one of the attributesin the data, thus reducing the dimensionality of the indexby one. In a lookup on the sorted dimension, we use binarysearch in each cell to get the range that needs to be scanned.Column files is indeed similar to the approach [14] with thedifference that it does not assume that the query workloadis known and hence uses the data distribution to arrangeand align the grid layout.

Full scan: Every item in the dataset is scanned and checkedagainst each query.

7.2 Results

7.2.1 TuningIn this experiment we measure and compare the execution

time for all indexes. We use the configuration that performsbest for each index. This configuration consists of chunksize for the full grid, chunk size and sort dimension for thecolumn files and the learned grid, and the node capacity(non-leaf and leaf capacity) of the R-Tree. For example,we evaluated different node capacities between 2 to 32 forthe for the R-Tree index and the best performance for eachexperiment (i.e. point queries and individually for each se-lectivity rate in range queries) was used. The best node sizefor R-Tree was between 8 and 12 for each test.

Note that because of memory constraints we limit any in-dex from using unreasonable amount of memory overhead.More specifically, we limit any index that would require morememory overhead for its index directory than memory oc-cupied by the underlying data itself. Memory usage of theindexes is shown later in Section 7.2.4.

We evaluate our results using range queries and pointqueries that are drawn randomly from each dataset. We de-fine a point query as a range query where the lower boundand upper bound in the matching hyper rectangle are equal.

7.2.2 Point and range queriesAs seen in Figure 6, the learned grid outperforms both the

R-Tree and full grid. Note that the main drawback in thecase of full grid is the higher index dimensionality and the

5

Airline (range) Airline (point) OSM (range) OSM (point)10−3

10−2

10−1

100

101

102

run tim

e (m

s)Learned Grid (primar )Learned Grid (outliers)

R-TreeFull Grid

Full Scan

Figure 6: Query run time performance on airline and OSMdata in range and point queries. Note the log scale.

35K 150K 750K 1.5Maverage query selectivity (points)

0

2

4

6

8

10

12

14

run tim

e (m

s)

Learned Grid (primary)Learned Grid (outliers)

R-Tree Column Files

Figure 7: Run time performance in range queries with dif-ferent selectivity values on airline data for the year 2008(7M)

fact that it is limited in terms of how many cells it can use.An example illustration for this in 2D was shown earlier inFigure 4. This is because with a skewed dataset, most gridcells become empty or very small in size. In addition, incomparison to column files, the learned grid benefits fromsmaller number of memory lookups. The decreased totalnumber of cells in a learned grid also translates to binarysearch on larger ranges in each cell, which makes the learnedgrid even more efficient.

7.2.3 Effect of selectivity in range queriesIn addition to this, we run the same experiment with the

range queries with selectivity sizes. In this experiment weuse the airline data for the year 2008 only and plot the re-sults in Figure 7 showing that the Learned Gird does notlose performance on larger/shorter queries. Note that, wecan check whether the query intersects with the primary, thesecondary, or both indexes; and run it against the appropri-ate indexes. For queries with larger selectivities, it is hencemore likely for both indexes to be invoked which results inmore invocation and larger overhead from the secondary in-dex.

7.2.4 Memory UsageFigure 8 plot the range query performance against mem-

ory overhead in the case of the learned grid, column filesand the R-Tree. As seen, all grid indexes have a sweet spot.This is because as we increase the number of cells, althoughwe are likely to scan fewer items, after a certain point theincreased pointer lookups starts to hurt performance mainlybecause there is diminishing returns in reducing the actual

102 104 106 108

memory overhead (bytes)

0.00

1.00

2.00

3.00

4.00

5.00

6.00

runtim

e (m

s)

Learned Grid (primary)Learned Grid (secondary) (Column Files)

Learned Grid (total)Column Files

R-Tree

(a) Airlines (7M)

102 103 104 105 106 107 108

memory overhead (bytes)

0.05

0.10

0.15

0.20

0.25

runt

ime

(ms)

Learned Grid (primary)Learned Grid (secondary) (Column Files)

Learned Grid (total)Column Files

R-Tree

(b) OSM (9M)

Figure 8: Grids suffer from excessive pointer lookups if theyare too large. Figure shows memory saved by the learnedgrid by reducing the dimensionality by one

items considered when increasing the grid size. In otherwords, it takes a lot of effort to improve the accuracy ofan unlearned grid after a certain point for skewed datasets.This effect is illustrated in Figure 4.

8. CONCLUSIONS & FUTURE WORKIn this paper we address the degradation of performance/query

execution time for every additionally indexed dimension (alsoreferred to as the curse of dimensionality). Instead of index-ing all dimensions, we learn soft functional dependencies,i.e., the correlation between different dimensions/attributes.By doing so, we no longer have to index the learned at-tributes and can thus reduce the number of dimensions in-dexed, thereby accelerating query execution and reducingmemory overhead. In case the learned attribute is queriedfor, we use the model (as well as the secondary index) tofind a starting point for scanning the data. As we show ex-perimentally, our approach uses substantially less memoryand also executes queries faster.

This work only studied the case where the correlation canessentially be learned using a line. Our idea could be ex-tended to cases where data points are split between twoseparate parallel lines. In such a case, multiple models canbe learned. Alternatively, we can learn a mixture of modelssuch as where dense points and linear models lie and indexthem separately. We leave this as future work.

6

9. REFERENCES[1] Geofabrik download server.

https://download.geofabrik.de. 2020-05-29.

[2] Probabilistic programming in python: Bayesianmodeling and probabilistic machine learning withtheano. https://github.com/pymc-devs/pymc3.2020-05-29.

[3] J. Ding, U. F. Minhas, H. Zhang, Y. Li, C. Wang,B. Chandramouli, J. Gehrke, D. Kossmann, andD. Lomet. Alex: an updatable adaptive learned index.arXiv preprint arXiv:1905.08898, 2019.

[4] A. Galakatos, M. Markovitch, C. Binnig, R. Fonseca,and T. Kraska. A-tree: A bounded approximate indexstructure. arXiv preprint arXiv:1801.10207, 2018.

[5] A. Hadian and T. Heinis. Considerations for handlingupdates in learned index structures. In Proceedings ofthe Second International Workshop on ExploitingArtificial Intelligence Techniques for DataManagement, pages 1–4, 2019.

[6] A. Hadian and T. Heinis. Interpolation-friendlyb-trees: Bridging the gap between algorithmic andlearned indexes. In EDBT, 2019.

[7] I. F. Ilyas, V. Markl, P. Haas, P. Brown, andA. Aboulnaga. Cords: automatic discovery ofcorrelations and soft functional dependencies. InProceedings of the 2004 International Conference onManagement of Data, pages 647–658, 2004.

[8] A. Kipf, R. Marcus, A. van Renen, M. Stoian,A. Kemper, T. Kraska, and T. Neumann. SOSD: ABenchmark for Learned Indexes. NeurIPS Workshopon Machine Learning for Systems, 2019.

[9] A. Kipf, R. Marcus, A. van Renen, M. Stoian,A. Kemper, T. Kraska, and T. Neumann. Radixspline:A single-pass learned index. 2020.

[10] T. Kraska, M. Alizadeh, A. Beutel, E. H. Chi, J. Ding,A. Kristo, G. Leclerc, S. Madden, H. Mao, andV. Nathan. Sagedb: A learned database system. InProceedings of the Biennial Conference on InnovativeData Systems Research (CIDR), 2019.

[11] T. Kraska, A. Beutel, E. H. Chi, J. Dean, andN. Polyzotis. The case for learned index structures. InProceedings of the 2018 International Conference onManagement of Data, pages 489–504, 2018.

[12] A. Llavesh, U. Sirin, R. West, and A. Ailamaki.Accelerating b+tree search by using simple machinelearning techniques. In Proceedings of the 1stInternational Workshop on Applied AI for DatabaseSystems and Applications, 2019.

[13] R. Marcus, E. Zhang, and T. Kraska. Cdfshop:Exploring and optimizing learned index structures. InProceedings of the 2020 ACM SIGMOD InternationalConference on Management of Data, pages 2789–2792,2020.

[14] V. Nathan, J. Ding, M. Alizadeh, and T. Kraska.Learning multi-dimensional indexes. In Proceedings ofthe 2020 ACM SIGMOD International Conference onManagement of Data, pages 985–1000, 2020.

[15] J. Nievergelt, H. Hinterberger, and K. C. Sevcik. Thegrid file: An adaptable, symmetric multi-key filestructure. In Conference of the European Cooperationin Informatics, pages 236–251. Springer, 1981.

7