Parallelization of XPath Queries using Modern XQuery Processors

06/20/2018 ∙ by Shigeyuki Sato, et al. ∙ 0

A practical and promising approach to parallelizing XPath queries was proposed by Bordawekar et al. in 2009, which enables parallelization on top of existing XML database engines. Although they experimentally demonstrated the speedup by their approach, their practice has already been out of date because the software environment has largely changed with the capability of XQuery processing. In this work, we implement their approach in two ways on top of a state-of-the-art XML database engine and experimentally demonstrate that our implementations can bring significant speedup on a commodity server.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Scalability and efficiency of XML processing have become increasingly important because XML data in the real world are steadily growing up. Parallel XML processing is a natural consequence in the current hardware environment that allows us to make lavish use of processor cores. Actually, parallel XQuery processors such as PAXQuery [5] and VXQuery [6] were developed for pursuing scalability. They, however, did not parallelize XPath queries, which characterize a core part of XML processing. There remains considerable room for improvement particularly regarding XPath queries.

Parallelization of XPath queries has also been studied but still far from practical use. Most of the existing studies [16, 11, 7, 15, 14, 8] were based on divide-and-conquer algorithms on a given XML document. Although these approaches are algorithmically sophisticated, they are, unfortunately, impractical in terms of engineering because they confine input queries to small subsets of XPath and necessitate implementing dedicated XML database engines. In contrast, Bordawekar et al. [4] presented an ad hoc yet practical approach that allows us to use off-the-shelf XML database engines for parallelization on shared-memory computers; it was based on cheap query split. In this work, we focus on the latter approach from a practical perspective.

Although Bordawekar et al.’s approach itself is promising in terms of engineering, their work has already been out of date in this day and age, particularly in terms of software environment. A big difference exists in sophistication of XML database engines. They used an XSLT processor (Xalan-C++ version 1.10) released in 2004, when a matter of the highest priority would have been standards conformance. Now, industrial-grade XML database engines such as BaseX111 are freely available and we thus can enjoy high-performance queries of high expressiveness. We therefore should implement parallelization with serious consideration of underlying XML database engines, in analogy with existing studies [9, 2] on efficient XPath query processing on relational database management systems. In summary, the following is our research question: How should we implement query-split parallelization on state-of-the-art XML database engines?

To answer this question, in this work, we have developed two implementations of query-split parallelization on top of BaseX, which implements XQuery and extensions efficiently [13] and involves a powerful query optimizer [18]. We have evaluated our implementations experimentally with non-trivial queries according to prior work [4] over gigabyte-scale datasets and achieved significant speedup on a modern server. Through this practice, we have discovered a simple way of accommodating query-split parallelization to the query optimization in BaseX.

Our main contributions are summarized as follows.

  • We have developed two implementations of query-split parallelization [4] (Sect. 2) on top of BaseX (Sect. 4). One is a simple revival of prior work [4] on BaseX; the other takes advantage of rich features of BaseX.

  • We have investigated the effects of query-split parallelization on the query optimization of BaseX and discovered a simple way of smooth integration of both (Sect. 5).

  • We have experimentally demonstrated that our implementations were able to achieve up to 4.86x speedup on a 12-core commodity server for non-trivial queries over gigabyte-scale datasets (Sect. 6).

2 Query-split Parallelization

In this section, we describe Bordawekar et al.’s approach [4] to parallel XPath query processing. We assume readers’ familiarity with XPath222

Bordawekar et al. presented a cheap approach to parallel evaluation of a single XPath query. Their approach is to split a given query into subqueries in an ad hoc manner and to evaluate them in parallel. Specifically, they proposed two strategies: query partitioning and data partitioning. Query partitioning is to split a given query into independent queries by using predicates, e.g., from [ or ] to [] and [], and from / to [position() <= 10]/ and [position() > 10]/. Data partitioning is to split a given query into a prefix query and a suffix query, e.g., from / to prefix and suffix , and to run the suffix query in parallel on each node in the result of the prefix query. Note that how to construct final results depends on split queries. If we split and-/or-predicates, we have to intersect/union results in order. If we perform position-based query partitioning and data partitioning, we have only to concatenate results in order.

Their approach is a clever engineering choice because it does not necessitate developing XML processors from scratch and enables us to extend efficient off-the-shelf XML database engines easily. This is a great advantage of their approach. A main disadvantage is, in contrast, that a priori decision of better query split is difficult because of its ad hoc nature. Particularly, query partitioning depends heavily both on queries and XML documents. Position-based query partitioning is almost useless in practice without use of statistics of a given document as in [3]. Data partitioning is easier to apply and generally outperformed query partitioning in their experimental comparison [4]. In this work, we therefore deal only with data partitioning.

In this paper, we use the same set of queries over XMark [17] datasets and the DBLP dataset as [4] except for DB3, which is a little modified from the original one for experiments (see Sect. 6). Tables 14 summarizes our target queries, where (a)–(c) mean variations of data partitioning and (a)–(b) except for XM6(b) and DB3(a) follow ones used in [4].

Key Query
XM1 /site//*[name(.)="emailaddress" or name(.)="annotation"
or name(.)="description"]
XM2 /site//incategory[./@category="category52"]/parent::item/@id
XM3 /site//open_auction/bidder[last()]
XM4 /site/regions/*/item[./location="United States" and ./quantity > 0
and ./payment="Creditcard" and ./description and ./name]
XM5 /site/open_auctions/open_auction/bidder/increase
XM6 /site/regions/*[name(.)="africa" or name(.)="asia"]/item/
Table 1: List of XPath queries for XMark dataset
Key Query
XM1(a) prefix = /site/*,
suffix = descendant-or-self::*[name(.)="emailaddress"
or name(.)="annotation" or name(.)="description"]
XM2(a) prefix = /site//incategory,
suffix = self::*[./@category="category52"]/parent::item/@id
XM2(b) prefix = /site/*,
suffix = descendant-or-self::incategory[./@category="category52"]/
XM2(c) prefix = db:attribute("xmark10", "category52"),
suffix = parent::incategory[ancestor::site/parent::document-node()]
XM3(a) prefix = /site//open_auction,  suffix = bidder[last()]
XM3(b) prefix = /site/*,
suffix = descendant-or-self::open_auction/bidder[last()]
XM3(c) prefix = /site/open_auctions/open_auction,  suffix = bidder[last()]
XM4(a) prefix = /site/regions/*,
suffix = item[./location="United States" and ./quantity > 0 and
./payment="Creditcard" and ./description and ./name]
XM4(b) prefix = /site/regions/*/item,
suffix = self::*[./location="United States" and ./quantity > 0 and
./payment="Creditcard" and ./description and ./name]
XM4(c) prefix = db:text("xmark10", "Creditcard")/parent::payment,
suffix = parent::item[parent::*/parent::regions/parent::site/
parent::document-node()][location = "United States"]
[0.0 < quantity][description][name]
XM5(a) prefix = /site/open_auctions/open_auction/bidder,  suffix = increase
XM5(b) prefix = /site/open_auctions/open_auction,  suffix = bidder/increase
XM6(a) prefix = /site/regions/*,
suffix = self::*[name(.)="africa" or name(.)="asia"]/item/
XM6(b) prefix = /site/regions/*[name(.)="africa" or name(.)="asia"]/item,
suffix = description/parlist/listitem
Table 2: List of split queries for XMark datasets
Key Query
DB1 /dblp/article/author
DB2 /dblp//title
DB3 /dblp/book[count(./following-sibling::book[1]/author)
< count(./author)]
Table 3: List of XPath queries for DBLP dataset
Key Query
DB1(a) prefix = /dblp/article,  suffix = author
DB2(a) prefix = /dblp/*,  suffix = title
DB2(b) prefix = /dblp/*,  suffix = descendant-or-self::*/title
DB3(a) prefix = /dblp/book,
suffix = self::*[count(./following-sibling::book[1]/author)
< count(./author)]
Table 4: List of split queries for DBLP datasets

3 The XML Database Engine BaseX

This section briefly describes the XML database engine BaseX. Refer to the official documentation333 for more details.

The following are BaseX’s features particularly important for this work:

  • Efficient native implementation of XQuery 3.1, especially sequence operations, and XQuery Update Facility [13];

  • Extension for database operations, especially index-based random access;

  • Extension for text processing, especially ft:tokenize;

  • Support for in-memory XML databases;

  • Query optimization based on various indices [18];

  • Support for concurrent transactions in the server mode.

The most important (practically essential) feature for our implementations is the index-based random access to nodes. BaseX offers indices that enable us to access any node in constant time. The PRE index, which is an integer that denotes a position in the document order, brings the fastest constant-time access on BaseX. Function db:node-pre returns the PRE value of a given node and function db:open-pre returns the node of a given PRE value. PRE values are well suited for representing the results of prefix queries because only an integer enables us to restart XPath navigation uniformly from any node.

BaseX implements the whole of XQuery efficiently. Particularly, sequence operations are very efficient due to sequence implementation based on finger trees; the length of sequence is returned by count in constant time and the subsequence of a specified range is extracted in logarithmic time. XQuery Update Facility over in-memory databases strongly supports efficient use of temporary databases. Function ft:tokenize, which tokenizes a given string to a sequence of token strings, enables efficient deserialization of sequences. Our server-side implementation described in the next section fully utilizes all these features.

BaseX’s query optimization is so powerful that it is not unusual to improve time complexity drastically. For example, the path index enables pruning traversal of descendants and the attribute index enables instant access to the nodes that have a specific attribute value. With aggressive inlining and constant propagation [18], BaseX exploits most constants including database metadata and PRE values found in a given query for query optimization. Prevention of spoiling it, as to be described in Sect. 5, is therefore of crucial importance for performance.

Lastly, BaseX can work efficiently in a client-server model. BaseX servers can handle concurrent transactions from BaseX clients with multiple threads. Read transactions including XPath queries are executed in parallel.

4 Implementing Data Partitioning with BaseX

In this section, we describe our two implementations called of data partitioning on top of BaseX. We call them the client-side implementation and the server-side implementation because of the difference in the way of managing the results of prefix queries.

Our implementations involve worker threads of simple BaseX clients that hold independent connections to the BaseX server. After the master thread issues a prefix query, each worker thread issues a suffix query.

In the rest of this section, we describe our implementations by using XM3(a) as a running example, assuming the input database to be named ’xmark’. Let be the number of threads.

4.1 Client-side Implementation

The client-side implementation is a simple implementation of data partitioning with database operations on BaseX. It sends the server a prefix query that returns the PRE values of hit nodes as follows.

for $x in db:open(’xmark’)/site//open_auction
 return db:node-pre($x)

Let this prefix query return sequence (2, 5, 42, 81, 109, 203) through a network. Letting , it is block-partitioned to (2, 5), (42, 81), and (109, 203), each of which is assigned to a worker thread. To avoid repetitive ping-pong between the client(s) and the server, we use the following suffix query template:

for $x in 
 return db:open-pre(’xmark’, $x)/bidder[last()] ,

where is a placeholder to be replaced with a concrete partition, e.g., (42, 81). Each thread instantiates this template with its own partition and sends the server the instantiated query.

4.2 Server-side Implementation

A necessary task on the results of a prefix query is to block-partition them. The client-side implementation does it simply on the client side. In fact, we can also implement it efficiently on the server side by utilizing BaseX’s features.

First, we prepare an in-memory XML database named ’tmp’ initialized with <root> </root>, which is a temporary database for storing the results of a prefix query. The prefix query is implemented as follows:

let $P := 
let $s := db:open(’xmark’)/site//open_auction ! db:node-pre(.)
for $i in 1 to $P
 return insert node element part { $blk_part($i, $P, $s) }
         as last into db:open(’tmp’)/root ,

where denotes a placeholder to be replaced with a concrete value of and $blk_part($i, $P, $s) denotes the $ith one of $P partitions of $s implemented in logarithmic time with sequence operations.

In the example case used earlier, ’tmp’ database results in the following:

 <part>2 5</part><part>42 81</part><part>109 203</part>
</root> ,

where a left superscript denotes a PRE value. Note that its document structure determines the PRE value of th partition to be .

A suffix query is implemented with deserialization of a partition as follows:

for $x in ft:tokenize(db:open-pre(’tmp’, ))
 return db:open-pre(’xmark’, xs:integer($x))/bidder[last()]) ,

where denotes a placeholder to be replaced with the PRE value of a target partition and the care of empty partitions is omitted for brevity.

The server-side implementation is more efficient because transferred data between clients and a server except for output are in a constant size.

5 Integration with Query Optimization

As mentioned in Sect. 3, BaseX is equipped with a powerful query optimizer. For example, BaseX optimizes XM3 to


on the basis of the path index, which brings knowledge that open_auction exists only immediately below open_auctions and open_auctions exists only immediately below site. The search space of this optimized query has significantly reduced because an expensive step of descendant-or-self axis is replaced with two cheap steps of child axes. It is worth noting that a more drastic result is observed in XM2, where the attribute index is exploited through function db:attribute.

Data partitioning converts a given query to two separate ones and therefore affects the capability of BaseX in query optimization. In fact, the suffix query of XM3(b) is not optimized to the corresponding part of optimized XM3 because BaseX does not utilize indices for optimizing queries starting from nodes specified with PRE values even if possible in principle. Most index-based optimizations are limited to queries starting from the document root. This is a reasonable design choice in query optimization because it is expensive to check all PRE values observed. However, it is unnecessary to check any PRE value that specifies the starting nodes of the suffix query because of the nature of data partitioning, of which BaseX is unaware. This discord between BaseX’s query optimization and data partitioning may incur serious performance degradation.

A simple way of resolving this discord is to apply data partitioning after BaseX’s query optimization. Data partitioning is applicable to any multi-step XPath query in principle. Even if an optimized query is thoroughly different from its original query as in XM2, it is entirely adequate to apply data partitioning to the optimized query, forgetting the original. In fact, XM2–4(c) are instances of such data partitioning after optimization. This coordination is so simple that we are still able to implement data partitioning only by using BaseX’s dumps of optimized queries without any modification on BaseX. This is a big benefit.

6 Experiments

In this section, we describe the experimental evaluation of our implementations.

6.1 Experimental Setting

We have conducted several experiments to evaluate the performance of the two implementations of parallel XPath queries. All the experiments were conducted on a computer that equipped with two Intel Xeon E5-2620 v3 CPUs ( cores, 2.4GHz, Hyper-Threading off) and 32-GB memory (DDR4-1866). The software environment we used was Java OpenJDK 64-Bit Server VM (ver. 9-internal, 9~b114-0ubuntu1 in Ubuntu 16.04 LTS) and BaseX ver. 9.0.1 (3a8b2ad6) with minor modifications to enable TCP_NODELAY.

We used two datasets: XMark and DBLP. We generated an XMark dataset with XMLgen444 giving -f 10, which was of 1.1 GB and had 16 million nodes. The root of the XMark tree has six children regions, people, open_auctions, closed_auctions, catgraph, and categories, which have 6, 255000, 120000, 97500, 10000, and 10000 children, respectively. Refer to [17] for more details of the XMark dataset. The DBLP dataset was the latest one downloaded from the DBLP website555, where the date of the downloaded file was August 29, 2017 and the dataset was of 2.2 GB and had 53 million nodes. The DBLP tree was flat; the root element has 6 million children.

We used the XPath queries shown in Tables 14, which are the same as those used in [4] except for DB3. We modified DB3 to alleviate the computational cost because the original one costs quadratic time, which was too costly to run over the latest DBLP dataset. We measured execution time until the client received all the results of suffix queries into byte streams. We executed both the client-side implementation and the server-side one for each parallel XPath query. The execution time does not include the loading time, that is, the input dataset was loaded into memory before the execution of queries. We measured the execution time of 25 runs after a warm-up run and picked up their median.

6.2 Total Execution Time

  Key orig client-side server-side Result size
seq par  ( ) seq par  ( ) prefix final
XM1(a) 37263 44443 18058 ( 2.06) 40084 16137 ( 2.31) 54 B 994 MB
XM2(a) 2 2856 1055 ( 0.00) 1075 808 ( 0.00) 6.62 MB 1.55 KB
XM2(b) 1029 937 ( 0.00) 1049 902 ( 0.00) 54 B
XM2(c) 3 4 ( 0.50) 3 4 ( 0.50) 671 B
XM3(a) 639 1180 304 ( 2.10) 848 302 ( 2.12) 1.08 MB 14.5 MB
XM3(b) 1816 1663 ( 0.38) 1857 1490 ( 0.43) 54 B
XM3(c) 1154 305 ( 2.10) 850 321 ( 1.99) 1.08 MB
XM4(a) 1148 1595 1595 ( 0.72) 1647 1084 ( 1.06) 49 B 26.4 MB
XM4(b) 1858 545 ( 2.11) 1402 493 ( 2.33) 1.75 MB
XM4(c) 1121 245 ( 4.69) 1232 236 ( 4.86) 106 KB
XM5(a) 715 2535 828 ( 0.86) 1288 651 ( 1.10) 5.38 MB 15.9 MB
XM5(b) 1209 462 ( 1.55) 955 432 ( 1.66) 1.08 MB
XM6(a) 820 954 929 ( 0.88) 970 933 ( 0.88) 49 B 22.2 MB
XM6(b) 1004 219 ( 3.74) 1084 207 ( 3.96) 183 KB
DB1(a) 6759 12498 4185 ( 1.62) 8451 2730 ( 2.48) 15.8 MB 176 MB
DB2(a) 15641 34729 8555 ( 1.83) 19191 6082 ( 2.57) 56.9 MB 423 MB
DB2(b) 34713 8564 ( 1.83) 19105 6405 ( 2.44) 56.9 MB
DB3(a) 888 1115 1092 ( 0.81) 1043 953 ( 0.93) 139 KB 1.9 MB
Table 5: Summary of execution time.

Table 5 summarizes the execution time of the queries. The “orig ”column shows the time for executing original queries XM1–XM6 and DB1–DB3 with BaseX’s xquery command. The “seq ” columns show the time for executing the prefix query and the suffix query with one thread. The “par ” columns show the time for executing the prefix query with one thread and the suffix query with 12 threads. The table also includes for reference the speedup of parallel queries with respect to original queries and the size of results of the prefix queries and the whole queries.

By using the pair of the prefix and suffix queries split at an appropriate step, we achieved speedups by factor about 2.0 for XM1 and XM3, and by factor of more than 3.7 for XM4 and XM6. The execution time of XM2 was very short because BaseX executed an optimized query that utilized the attribute index as mentioned in Sect. 5. By designing the parallel query XM2(c) based on that optimized query, the execution time of parallel query was just longer than that of the optimized query by 2 ms. Comparing the two implementations, we observed that the server-side implementation ran faster for most queries.

Although some of parallel queries did not reached the performance of their original queries, these were reasonable. XM2(a)–(b) were due to index-based optimizations; XM2(c) was too cheap to benefit from parallel evaluation. XM4(a) and XM6(a) were due to load imbalance derived from data skewness. XM5(a) and DB3(a) were due to the cheapness of the suffix queries compared to the prefix ones; their suffix queries visited few nodes from a starting one and merely filtered the results of their prefix queries.

6.3 Breakdown of Execution Time

prefix suffix
P=1 P=2 P=3 P=6 P=12  ( )
XM1(a) 5 44438 27063 27296 27601 18053  ( 2.46 )
XM3(c) 93 1061 656 423 251 212  ( 5.00 )
XM4(c) 23 1098 766 563 310 222  ( 4.95 )
XM5(b) 89 1120 716 549 395 373  ( 3.00 )
XM6(b) 21 983 691 525 268 198  ( 4.96 )
DB1(a) 1395 11103 6172 10992 5614 2790  ( 3.98 )
DB2(a) 2748 31981 20502 20077 9401 5807  ( 5.51 )
DB3(a) 602 513 562 555 527 490  ( 1.05 )
Table 6: Breakdown of execution time for client-side implementation
prefix suffix
P=1 P=2 P=3 P=6 P=12  ( )
XM1(a) 7 40077 27162 26308 16342 16130  ( 2.48 )
XM3(c) 78 772 446 322 209 243  ( 3.18 )
XM4(c) 18 1214 736 548 1668 218  ( 5.57 )
XM5(b) 78 877 545 412 691 354  ( 2.48 )
XM6(b) 20 1064 632 482 257 187  ( 5.69 )
DB1(a) 1204 7247 4165 2861 1584 1526  ( 4.75 )
DB2(a) 2251 16940 11470 7962 4520 3831  ( 4.42 )
DB3(a) 518 525 439 450 415 435  ( 1.21 )
Table 7: Breakdown of execution time for server-side implementation

To investigate the execution time in detail, we executed parallel queries XM1(a), XM3(c), XM4(c), XM5(b), XM6(b), DB1(a), DB2(a) and DB3(a) with , 2, 3, 6, and 12 threads. Tables 6 and 7 show the breakdown of the execution time divided into two phases: prefix query and suffix query. In these tables, the speedup is calculated with respect to the execution time of suffix queries with one thread.

From Tables 6 and 7, we can find several interesting observations. First, the execution time of prefix queries was almost proportional to their result sizes and almost the same between the two implementations (except for DB2(a)). Comparing the two implementations, we can observe that the server-side implementation performed better than the client-side implementation for most suffix queries. These results suffice for concluding that the server-side implementation is, as expected, more efficient.

Next, we analyze the dominant factor of the performance gaps between the client-side and the server-side. Although the performance gaps of prefix queries should be mainly the difference between sending data to clients on localhost and storing data into memory, it was not significant. Communication cost, which is our expected advantage of the server-side, therefore did not explain the dominant factor of total performance gaps.

By examining the logs of the BaseX server, we have found that the dominant factor was the parsing of suffix queries. Since the client-side implementation sends a suffix query of length linearly proportional to the result size of a prefix query, it can be long. In fact, the prefix query of DB1(a) resulted in 15.8 MB and BaseX took more than 700 ms for parsing the query string in the client-side implementation; it took less than 1 ms in the server-side implementation. Note that sending and receiving a long query would not cost so much in our experiments because localhost communication was almost as fast as local memory access. Parsing in the client-side implementation is more expensive than deserialization in the server-side implementation. More importantly, parsing is essentially not streamable: before finishing parsing a query string, BaseX cannot start to evaluate it, whereas the deserialization in the server-side is streamable. We conclude that this difference in streamability was the dominant factor of the performance gaps between the client-side and the server-side.

Lastly, we should admit a conundrum that we could not solve. Several queries performed poorly at specific ; e.g., DB1(a) at for the client-side implementation and XM4(c) and XM5(b) at for the server-side implementation resulted unreasonably. Because these results were reproducible, we conjecture that they were derived from the mechanism of BaseX.

6.4 Scalability Analysis

When we analyze the speedup of parallel execution, the ratio of sequential execution part to the whole computation is important because it limits the possible speedup by Amdahl’s law. In the two implementations, most of the sequential execution part consists in the prefix query. The ratio of the sequential execution part was small in general: more specifically, the client-side implementation had smaller ratio (e.g. 12.6 % for DB1(a)) than the server-side implementation had (e.g. 16.6 % for DB1(a)). In our implementations, the suffix queries were independently executed in parallel through individual connections to the BaseX server. The speedups we observed for the suffix queries were, however, smaller than we had expected. We also noticed that in some cases the execution time was longer with more threads (for example, XM3(c) P=12 with the server-side implementation).

XM1(a)  1.51/ 1.02   1.59/ 1.04   2.83/ 1.15    2.87/ 1.15
XM3(c) 1.95/ 1.12 2.84/ 1.18 5.38/ 1.46 9.01/ 2.84
XM4(c) 1.97/ 1.19 2.82/ 1.27 2.59/ 3.55 10.25/ 1.84
XM5(b) 1.91/ 1.19 2.79/ 1.31 3.97/ 3.13 11.31/ 4.57
XM6(b) 1.94/ 1.15 2.76/ 1.25 5.40/ 1.30 10.35/ 1.82
DB1(a) 1.95/ 1.12 2.86/ 1.13 5.69/ 1.24 10.79/ 2.27
DB2(a) 1.58/ 1.07 2.38/ 1.12 4.68/ 1.25 9.80/ 2.22
DB3(a) 1.16/ 0.97 1.24/ 1.06 1.45/ 1.15 1.83/ 1.52
Table 8: Load balance and increase of work of server-side implementation (load-balance/increase-of-work)

To understand the reason why the speedups of the suffix queries were small, we made two more analyses (Table 8). The degree of load balance in processing suffix queries was calculated as the cumulative execution time divided the maximum execution time:

where denotes the execution time of the th suffix query in parallel with threads. The increase of work of the suffix queries was calculated by the cumulative execution time divided by the single-thread execution time:

From Table 8, we can observe the reasons of the small speedups in the suffix queries. Obvious load imbalances were incurred in XM1(a) and DB3(a) for different reasons. For XM1(a), the hit nodes by the prefix query were very few and less than the number of cores. For DB3(a), the computational cost of each suffix query was quite different because of data skewness. For the other cases, we achieved good load balance, and the degrees of load balance were more than 75% even with 12 threads, which means that load imbalance was not the main cause of small speedups for those queries. The increase of work was significant for XM5(b) and XM3(c), and it was the main cause that the queries XM5(b) and XM3(c) had small speedups. For the other queries, we observed very small increase of work until 6 threads, but the work increased when 12 threads. Such an increase of work is often caused by contention to memory access, and it is inevitable in shared-memory multicore computers.

7 Related Work

Most of existing studies [16, 11, 7, 15, 14, 8, 10, 1] on parallel evaluation of XPath queries were based on divide-and-conquer algorithms on a given document. They adopted different ways of dividing a document into fragments. Cong et al. [7] and Nomura et al. [15] adopted a tree-shaped fragment that contains original nodes and hole nodes, where a hole node represents a link to a missing subtree, and represented the whole document as a tree of fragments. The key part of their approaches to decouple dependencies between evaluations on fragments so as to perform them in parallel. Kling et al. [14] modeled fragmentation as horizontal and vertical in terms of schemas. Horizontal fragmentation is to divide a document tree with replication of top part so as to preserve the path from the root to each node of every fragment, i.e., preserve its schema, where the whole document is a simple collection of fragments. Vertical fragmentation is to divide, in contrast, a document tree together with its schema, where each fragment is a forest conforming a fragmented schema, and thus to represent the whole document as connected graphs of fragments. In parallel pushdown transducers [16, 11], a given document is modeled as a sequence of matched brackets and a fragment is represented as a sequence of unmatched brackets, which are, in contrast, modeled as a special kind of tree nodes in partial trees [10].

All these approaches are quite advantageous to scalability. It has been exemplified by their accommodation [7, 8, 1] to processing by Hadoop MapReduce, which is a common infrastructure for large-scale data processing, and to parallel streaming [16, 11]. Unfortunately, they are inconvenient in practice because their algorithms were designed for evaluating small subsets (e.g., child and descendant axes with predicates in [7, 14]) of XPath often by using dedicated data structures for XML data storage. The necessity of such internal data structures imposes implementing XML database engines nearly from scratch in practice. Even a fallback into serial evaluation of queries beyond a tractable subset then becomes nontrivial. In summary, these approaches are hard in engineering.

Surprisingly, Bordawekar et al.’s approach [4] has not been well studied regardless of its great virtue in engineering. They studied by themselves on the sophistication of the query split strategies based on the statistics of a given document [3]. Since that, follow-up studies had not been seen for a long time, but most recently, Karsin et al. [12] has studied on the scheduling of suffix query tasks. They investigated three kinds of task generation and showed experimentally their trade-off between overhead and load imbalance. However, they did not focus on the great advantage in engineering and used their own sequential query engine for pursuing experimental performance predictability. In contrast, our work focuses on how to integrate Bordawekar et al.’s approach into state-of-the-art XML database engines from a practical perspective.

8 Conclusion

In this paper, we have reassesed data-partitioning parallelization of XPath queries proposed by Bordawekar et al. [4] on top of BaseX. We have developed two implementations on the basis of BaseX’s features. The server-side implementation, which particularly exploits rich features of BaseX, achieved roughly better experimental speedup because of lower overhead in querying.

Although this paper focuses only on BaseX, we have also tried to implement data partitioning on top of other XML processors (e.g., Xalan-Java) and XML database management systems (e.g., Microsoft SQL Server). Unfortunately, implementing data partitioning on top of Xalan-Java and SQL Server has turned to be practically infeasible. The latest implementation of Xalan-Java is designed for stream processing and therefore provides no API for index-based access. Although SQL Server 2017 provides an API for XML indices, direct manipulation of their actual values is prohibited and operations are quite restrictive. In contrast, BaseX allows users to manipulate index values directly and provides various efficient operations on them. We therefore have made a success of implementing data partitioning in two different ways. That is, our work also has the implication of demonstrating practical requirements on XML database engines for data partitioning—we believe it to be helpful for development of XML database systems.


We would like to thank Christian Grün of the BaseX team for his technical comments and feedback on BaseX.


  • [1] Bi, X., Zhao, X.G., Wang, G.R.: Efficient processing of distributed Twig queries based on node distribution. Journal of Computer Science and Technology 32(1), 78––92 (2017)
  • [2] Boncz, P., Grust, T., van Keulen, M., Manegold, S., Rittinger, J., Teubner, J.: MonetDB/XQuery: A fast XQuery processor powered by a relational engine. In: Proc. the 2006 ACM SIGMOD International Conference on Management of Data (SIGMOD ’06). pp. 479–490. ACM (2006)
  • [3] Bordawekar, R., Lim, L., Kementsietsidis, A., Kok, B.W.L.: Statistics-based parallelization of XPath queries in shared memory systems. In: Proc. the 13th International Conference on Extending Database Technology (EDBT ’10). pp. 159–170. ACM (2010)
  • [4] Bordawekar, R., Lim, L., Shmueli, O.: Parallelization of XPath queries using multi-core processors: Challenges and experiences. In: Proc. the 12th International Conference on Extending Database Technology (EDBT ’09). pp. 180–191. ACM (2009)
  • [5] Camacho-Rodríguez, J., Colazzo, D., Manolescu, I.: PAXQuery: Efficient parallel processing of complex XQuery. IEEE Trans. Knowl. Data Eng. 27(7), 1977–1991 (2015)
  • [6] Carman Jr., E.P., Westmann, T., Borkar, V.R., Carey, M.J., Tsotras, V.J.: A scalable parallel XQuery processor. In: 2015 IEEE International Conference on Big Data (Big Data ’15). pp. 164–173 (2015)
  • [7] Cong, G., Fan, W., Kementsietsidis, A., Li, J., Liu, X.: Partial evaluation for distributed XPath query processing and beyond. ACM Trans. Database Syst. 37(4) (2012)
  • [8] Damigos, M., Gergatsoulis, M., Plitsos, S.: Distributed processing of XPath queries using MapReduce. In: Proc. the 17th East European Conference on Advances in Databases and Information Systems (ADBIS ’13). Advances in Intelligent Systems and Computing, vol. 241, pp. 69–77. Springer (2014)
  • [9] Grust, T., Rittinger, J., Teubner, J.: Why off-the-shelf RDBMSs are better at XPath than you might expect. In: Proceedings of the 2007 ACM SIGMOD International Conference on Management of Data (SIGMOD ’07). pp. 949–958. ACM (2007)
  • [10] Hao, W., Matsuzaki, K.: A partial-tree-based approach for XPath query on large XML trees. J. Inf. Process. 24(2), 425–438 (2016)
  • [11] Jiang, L., Zhao, Z.: Grammar-aware parallelization for scalable XPath querying. In: Proc. the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’17). pp. 371–383. ACM (2017)
  • [12] Karsin, B., Casanova, H., Lim, L.: Low-latency XPath query evaluation on multi-core processors. In: Proc. the 50th Hawaii International Conference on System Sciences (HICSS ’17). pp. 6222–6231 (2017)
  • [13] Kircher, L., Grossniklaus, M., Grün, C., Scholl, M.H.: Efficient structural bulk updates on the Pre/Dist/Size XML encoding. In: Proc. the 31st IEEE International Conference on Data Engineering (ICDE ’15). pp. 447–458. IEEE (2015)
  • [14] Kling, P., Özsu, M.T., Daudjee, K.: Scaling XML query processing: Distribution, localization and pruning. Distrib. Parallel Databases 29(5–6), 445–490 (2011)
  • [15] Nomura, Y., Emoto, K., Matsuzaki, K., Hu, Z., Takeichi, M.: Parallelization of XPath queries with tree skeletons. Computer Software 24(3), 51–62 (2007), (in Japanese)
  • [16] Ogden, P., Thomas, D., Pietzuch, P.: Scalable XML query processing using parallel pushdown transducers. PVLDB 6(14), 1738–1749 (2013)
  • [17] Schmidt, A., Waas, F., Kersten, M., Carey, M.J., Manolescu, I., Busse, R.: XMark: A benchmark for XML data management. In: Proc. the 28th International Conference on Very Large Data Bases (VLDB ’02). pp. 974–985. VLDB Endowment (2002)
  • [18] Wörteler, L., Grossniklaus, M., Grün, C., Scholl, M.H.: Function inlining in XQuery 3.0 optimization. In: Proc. the 15th Symposium on Database Programming Languages (DBPL ’15). pp. 45–48. ACM (2015)