Path Sharing and Predicate Evaluation for High-Performance XML Filtering*

Transcription

1 Path Sharing and Prediate Evaluation for High-Performane XML Filtering Yanlei Diao, Mihael J. Franklin, Hao Zhang, Peter Fisher EECS, University of California, Berkeley {diaoyl, franklin, nhz, Astrat XML filtering systems aim to provide fast mathing of douments to large numers of query speifiations ontaining oth strutureased and value-ased prediates. These two types of prediates present very different hallenges for mathing algorithms. Previous work has addressed struture and value mathing to various degrees, ut has not investigated how to est integrate these two funtions. In this work, we first present a highly-effiient, NFAased struture mathing approah that exploits ommonality among path expressions. We then propose two alternative tehniques for extending this model with value-ased prediates. These approahes are then evaluated experimentally. Our results show that there are sustantial differenes in the performane of these tehniques, demonstrating that to e most effetive, XML filtering systems must indeed address the interation of strutural and ontentased aspets of mathing. Introdution The emergene of XML as a ommon mark-up language for data interhange on the Internet has spawned signifiant interest in tehniques for filtering and ontentased routing of XML data. In an XML filtering system, ontinuously arriving streams of XML douments are passed through a filter engine (see Figure ), that mathes douments to queries and routes the mathed the douments to users, systems, or even to other routers. Queries in these systems are expressed in a language suh as XPath, whih provides prediates over struture (i.e., Permission to opy without fee all or part of this material is granted provided that the opies are not made or distriuted for diret ommerial advantage, the VLDB opyright notie and the title of the puliation and its date appear, and notie is given that opying is y permission This work of has the een Very supported Large Data in Base part Endowment. y the National To opy otherwise, Siene or Foundation to repulish, under requires ITR a fee grant and/or IIS , speial permission and from the y Endowment IBM, Mirosoft, and the UC MICRO program. Proeedings of the 8th VLDB Conferene, Hong Kong, China, 00 Data Soure Data Soure Data Soure XML streams A Filter Engine user queries query results Fig. : Arhiteture of an XML filtering system path expressions) and value (i.e., node filters). In the past few years, there have een a numer of efforts to uild effiient large-sale XML filtering systems. While most of these systems support oth struture and value mathing to some extent, they have tended to emphasize either the proessing of path expressions (e.g., XFilter [AF00], WeFilter [PFL0], CQMC [OKA0], XTrie [CFG0]), or the proessing of value-ased prediates (e.g., TriggerMan [HCH99], NiagraCQ [CDT00], Le Susrie [FJL0]). Thus, even though most systems have inluded oth aspets of mathing, none of the prior work has foused on the fundamental issues that arise in their integration.. Struture Mathing For struture mathing, the natural approah has een to adopt some form of Finite State Mahine (FSM) in whih elements of path expressions are mapped to mahine states. Arriving XML douments are then parsed with an event-ased parser; the events raised during parsing are used to drive the mahine through its various transitions. A query is determined to math a doument if during parsing, an aepting state for that query is reahed. We have developed a system, alled YFilter, that employs a novel struture-mathing approah ased on Nondeterministi Finite Automata (NFA). In a largesale filtering environment, NFAs have the signifiant advantage that the numer of mahine states required to represent even large numers of path expressions an e kept relatively small. The NFA-ased approah naturally supports the sharing of proessing for overlapping queries, and has other pratial advantages inluding: ) the aility to support more ompliated doument types (e.g., with reursive nesting) and queries (e.g., with Draft Sumitted for Puliation, Feruary, 00

2 multiple wildards and anestor-desendent axes), and ) inremental onstrution and maintenane. While in general there may e onern that an NFAased approah ould prove ineffiient, our results show that YFilter is suffiiently fast. When using it for proessing many (i.e., 0 s or 00 s of thousands) queries, struture mathing is no longer the dominant ost of XML filtering. Thus, while we make no laims that YFilter is the fastest possile struture-mathing engine, we elieve that from a pratial standpoint, the omination of fast proessing, flexiility, and ease of maintenane, make YFilter an exellent hoie for large-sale XML filtering.. Value-ased Prediates Given the NFA-ased struture-mathing engine, an intuitive approah to supporting value-ased prediates would e to simply extend the NFA y inluding prediates as laels on additional transitions etween states. Unfortunately, suh an approah would result in a potentially huge inrease in the numer of states in the NFA, and would also destroy the sharing of path expressions that is a primary advantage of the NFA. For this reason, we have investigated several alternative approahes to omining struture-ased and value-ased filtering in YFilter. Similar to traditional relational query proessing, the plaement of prediate evaluation in relation to the other aspets of suh proessing an have a major impat on performane. Relational systems use the heuristi of pushing heap seletions as far as possile down the query plan so that they are proessed early in the exeution. Following this intuition, we have developed an approah alled Inline, that proesses value-ased prediates as soon as the relevant state is reahed during struture mathing. In addition, we have developed an alternative approah, alled Seletion Postponed, that waits until an aepting state is reahed during struture mathing, and at that point applies all the value-ased prediates for the mathed queries. As we will see, the tradeoffs in prediate proessing for XML filtering differ sustantially from those found in more traditional environments..3 Contriutions and Overview In this paper, we present YFilter, an XML filtering engine that integrates struture-ased and value-ased proessing. The ontriutions inlude the following: We desrie a novel NFA-ased struture mathing approah that provides exellent performane and flexiility for large-sale filtering environments. We propose two alternative methods for integrating value-ased prediate proessing with the NFA-ased engine. We present results of a detailed performane study of an implementation of YFilter, fousing first on the filtering time for path expressions, and then on the omparison of the two methods for value-ased proessing. This latter study is, to our knowledge, the first study foused on alternative approahes to the important issue of omined struture and valueased filtering. The remainder of the paper is organized as follows. The NFA struture mathing approah and our alternatives for value-ased prediates are presented in Setions and 3 respetively. We report the results of our performane study in Setions 4 and 5. We address related work in Setion 6, and present onlusions in Setion 7. NFA Proessing for Path Expressions In this work, we fous on queries that are written in a suset of XPath [CD99]. XPath allows parts of XML douments to e addressed aording to their logial struture. A query path expression in XPath is omposed of a sequene of loation steps. Eah loation step onsists of an axis, a node test and zero or more prediates. An axis speifies the hierarhial relationship etween the nodes. We fous on two ommon axes: the parent-hild operator /, and the desendent-or-self operator //. We support node tests that are speified y either an element name or the wildard operator, whih mathes any element name. Prediates an e applied to attriutes of an element, to the ontents of an element, or may ontain referenes to other elements in the doument. In this setion, we desrie our NFA-ased proessing for struture mathing. Value-ased prediates are disussed in detail in Setion 3.. An NFA-ased Model with Output Any single path expression written using the axes and node tests desried aove an e transformed into a regular expression. Thus, there exists a Finite State Mahine (FSM) that aepts the language desried y suh a path expression [HU79]. An ovious way to handle multiple queries in a filtering system, would e to uild an individual FSM for eah query, and to exeute all of these mahines eah time a new XML doument arrives. XFilter [AF00] took this approah, ut used a sophistiated indexing sheme to identify only potentially relevant mahines. It then exeuted all of these mahines simultaneously. The drawak of suh an approah, however, is that it does not exploit any ommonality that may exist among the path expressions. If two path expressions share a suexpression, the language desried y that su-expression an e aepted y a single FSM. For large-sale filtering of XML data, exploiting suh ommonality is the key to salaility. For this reason, we have taken a different approah. Rather than representing eah query individually, we omine all of them into a single NFA. This single mahine is effetively a trie over the strings representing the strutural omponents of the path expressions. As The following-siling and preeding-siling axes are not onsidered yet, so only unordered mathing is supported urrently. Draft Sumitted for Puliation, Feruary, 00

3 Q=/a/ Q=/a/ Q3=/a// Q4=/a/// Q5=/a// Q6=/a// Q7=/a/// Q8=/a// a {Q} {Q} {Q3, Q8} {Q4} {Q6} {Q5} {Q7} of filtering. Rather, other osts suh as doument parsing and result olletion are in many ases more expensive than the asi path mathing, partiularly for systems with large numers of similar queries. Thus, while it may in fat e possile to further improve path mathing speed, we elieve that the sustantial enefits of flexiility and ease of maintenane provided y the NFA model outweigh any marginal performane improvements that remain to e gained y even faster path mathing. We revisit this issue in Setion 4 Fig. : XPath queries and a orresponding NFA suh, all ommon prefixes of the paths are represented only one in the struture. Figure shows an example of suh an NFA, representing eight queries (we desrie the proess for onstruting suh a mahine in the following setion). A irle denotes a state. Two onentri irles denote an aepting state; suh states are also marked with the IDs of the queries they represent. A direted edge represents a transition. The symol on an edge represents the input that triggers the transition. The speial symol mathes any element. The symol is used to mark a transition that requires no input. In the figure, shaded irles represent states shared y queries. Note that the ommon prefixes of all the queries are shared. Also note that the NFA ontains multiple aepting states. While eah query in the NFA has only a single aepting state, the NFA represents multiple queries. Idential (and struturally equivalent) queries share the same aepting state (reall that at the point in the disussion, we are not onsidering prediates). This NFA an e formally defined as a Moore Mahine [HU79]. The output funtion of the Moore Mahine here is a mapping from the set of aepting states to a partitioning of identifiers of all queries in the system, where eah partition ontains the identifiers of all the queries that share the aepting state. Some Comments on Effiieny A key enefit of using an NFA-ased approah is the tremendous redution in mahine size it affords. Of ourse, it is reasonale to e onerned that using an NFA-ased model ould lead to performane prolems due to (for example) the need to support multiple transitions from eah state. A standard tehnique for avoiding suh overhead is to onvert the NFA into an equivalent DFA [HU79]. A straightforward onversion ould theoretially result in severe salaility prolems due to an explosion in the numer states. But, as pointed out in [OS0], this explosion an e avoided in many ases y plaing restritions on the set of DTDs (i.e., doument types) and queries supported, and lazily onstruting the DFA. Our experimental results (desried in Setion 4), however, indiate that suh onerns aout NFA performane in this environment are unwarranted. In fat, in the YFilter system, path evaluation (using the NFA) is suffiiently fast, that it is typially not the dominant ost. Construting a Comined NFA Having presented the asi NFA model used y YFilter, we now desrie an inremental proess for NFA onstrution and maintenane. The shared NFA shown in Figure was the result of applying this proess to the eight queries shown in that figure. The four asi loation steps in our suset of XPath are /a, //a, / and //, where a is an aritrary symol from the alphaet onsisting of all elements defined in a DTD, and is the wildard operator. Figure 3 shows the direted graphs, alled NFA fragments, that orrespond to these asi loation steps. Note that in the NFA fragments onstruted for loation steps with //, we introdue an -transition moving to a state with a self-loop. This -transition is needed so that when omining NFA fragments representing // and / steps, the resulting NFA aurately maintains the different semantis of oth steps (see the examples in Figure 4 elow). The NFA for a path expression, denoted as NFA p, an e uilt y onatenating all the NFA fragments for its loation steps. The final state of this NFA p is the (only) aepting state for the expression. NFA p s are omined into a single NFA as follows: There is a single initial state shared y all NFA p s. To insert a new NFA p, we traverse the omined NFA until either: ) the aepting state of the NFA p is reahed, or ) a state is reahed for whih there is no transition that mathes the orresponding transition of the NFA p. In the first ase, we make that final state an aepting state (if it is not already one) and add the query ID to the query set assoiated with the aepting state. In the seond ase, we reate a new ranh from the last state reahed in the omined NFA. This ranh onsists of the mismathed transition and the remainder of the NFA p. Figure 4 provides four examples of this proess. Figure 4(a) shows the proess of merging a fragment for loation step /a with a state in the omined NFA that represents a / step. We do not omine the edge marked y a and the edge marked y into one marked y a, as in a standard NFA, eause the states after edge a and edge differ in their outputs, so they annot e omined. For the same reason, this proess treats the symol in the way that it treats the other symols in the alphaet, as shown in Figure 4(). Figure 4() shows the proess of merging a //a step with a / step, while Figure 4(d) shows the merging of a //a step with a // step. Here we see why we need the Draft Sumitted for Puliation, Feruary, 00 3

4 a /a //a a / // a a a a a a Loation steps NFA fragments (a) () () (d) Fig. 3: NFA fragments of asi loation steps Fig. 4: Comining NFA Fragments -transition in the NFA fragment for //a. Without it, when we omine the fragment with the NFA fragment for /, the latter would e semantially hanged to //. The merging proess for // with other fragments (not shown) is analogous to that for //a. The and // operators introdue Non-determinism into the model. requires two edges, one marked y the input symol and the other y, to e followed. The desendent-or-self operator // means the assoiated node test an e satisfied at any level at or elow the urrent doument level. In the orresponding NFA model, if a mathing symol is read at the state with a self-loop, the proessing must oth transition to the next state, and remain in the urrent state awaiting further input. It is important to note that eause NFA onstrution in YFilter is an inremental proess, new queries an easily e added to an existing system. This ease of maintenane is a key enefit of the NFA-ased approah.3 Implementing the NFA Struture The previous setion desried the logial onstrution of the NFA model. For effiient exeution we implement the NFA using a hash tale-ased approah, whih has een shown to have low time omplexity for inserting/deleting states, inserting/deleting transitions, and atually performing the transitions [Wat97]. In this approah, a data struture is reated for eah state, ontaining: ) The ID of the state, ) type information (i.e., if it is an aepting state or a //-hild as desried elow), 3) a small hash tale that ontains all the legal transitions from that state, and 4) for aepting states, an ID list of the orresponding queries. The transition hash tale for eah state ontains [symol, stateid] pairs where the symol, whih is the key, indiates the lael of the outgoing transition (i.e., element name,, or ) and the stateid identifies the hild state that the transition leads to. Note that the hild states of the transitions are treated speially. Reall that suh states have a self-loop marked with (see Figure 3). For suh states, (alled //-hild states) we do not index the self-loop. As desried in the next setion, this is possile eause transitions marked with are treated speially y the exeution mehanism..4 Exeuting the NFA Having walked through the logial onstrution and physial implementation we an now desrie the exeution of the mahine. In YFilter, the streaming data is a sequene of XML douments. Eah XML doument omprises well-formed start-end element pairs with aritrary nesting. As suh, simply treating the XML doument as an input string is eyond the sope of any language aepted y a FSM. One way to solve this prolem would e to shred eah XML doument in to a set of root-to-leaf paths, and to invoke the NFA on eah of these. Suh an approah, however, is likely to perform signifiant redundant proessing due to the ommonality of the path prefixes. Instead, similar to other approahes [AF00, CFG0, et] we hose to exeute the NFA in an event-driven fashion and use a stak mehanism to enale aktraking. As an arriving doument is parsed, the events raised y the parser drive the transitions in the NFA. In this way, an element in a doument is proessed only one. On the other hand, the nesting of XML elements requires that when an end-of-element event is raised, NFA exeution must aktrak to the states it was in when the orresponding start-of-element was raised. Sine in an NFA, many states an e ative simultaneously, the run-time stak mehanism must e apale of traking multiple ative paths. Finally, it is important to note that, unlike a traditional NFA, whose goal is to find one aepting state for an input, our NFA exeution must ontinue until all potential aepting states have een reahed. This is eause we must find all queries that math the input doument. When an XML doument arrives to e parsed, the exeution of the NFA egins at the initial state. When a new element name is read from the doument, the NFA exeution follows all mathing transitions from all urrently ative states. The transitions are performed as follows: For eah ative state, four heks are performed. First, the inoming element name is looked up in the state s hash tale. If it is present, the orresponding stateid is added to a set of target states. A transition marked y the symol is heked in the same way. Then, the type information of the state is heked. If the state itself is a //-hild state, then its own stateid Draft Sumitted for Puliation, Feruary, 00 4

5 Index a 3 {Q} 5 {Q3, Q8} 4 {Q} {Q4} {Q6} 0 9 {Q5} 3 {Q7} An XML fragment <a> <> <> </> </> </a> Runtime Stak initial read </> read <a> read </> read <> math Q read </a> read <> math Q3 Q8 Q5 Q6 Q4 Fig. 5: An example of NFA exeution is added to the set, whih effetively implements a self-loop in the omined NFA. Finally, to perform an -transition, the hash tale is heked for the symol, and if one is present, the //-hild state indiated y the orresponding stateid is proessed reursively, aording to these same rules. After all the urrently ative states have een heked in this manner, the set of target states is pushed onto the top of the run-time stak. They then eome the ative states for the next event. When an end-of-element is enountered, aktraking is performed y simply popping the top set of states off the stak. Note that when an aepting state is reahed during proessing, the identifiers of all queries assoiated with the state are olleted and added to an output data struture. 3 An example of this exeution model is shown in Figure 5. On the left of the figure is the index reated for the NFA of Figure. The numer on the top-left of eah hash tale is a state ID and hash tales with a old order represent aepting states. The right of the figure shows the evolution of the ontents of the runtime stak as an example XML doument is parsed. In the stak, eah state is represented y its ID. An underlined ID indiates that the state is a //-hild. 3 Prediate Evaluation As stated in the introdution, previous work on information filtering has emphasized either strutureased filtering or ontent-ased filtering. In general, however, languages suh as XPath allow the speifiation of queries that ontain oth types of onstraints. Thus, a primary goal and ontriution of our work is to explore how to effiiently support omined struture/ontent queries for large-sale filtering. XPath prediates an impose onstraints on elements in an XML doument y addressing properties of elements, suh as their ontent, their position, and their attriutes. Examples inlude: Existene or the value of an attriute in an element, e.g., /nitf[@id], /nitf[@id >= 5]; The text data of an element, e.g., /nitf//title[.= XPath ]. The position of an element, e.g. /nitf/head/meta [position()=], whih means selet the seond meta hild of head that is a hild of nitf. Any numer of these prediates an e attahed to a loation step in a query. Prediates an also referene another path in the doument. Suh nested paths are handled y deomposing them into separate paths in the NFA and performing post-proessing to ensure that all paths of a query are satisfied (a similar tehnique is employed in XFilter). Due to spae onstraints we fous in this setion on prediates that do not ontain suh nested paths. An intuitive approah to prediate evaluation is to simply extend the NFA model desried in the Setion. y inluding prediates as laels on additional transitions from the states representing the loation steps they are assoiated with. Unfortunately, suh an approah would result in a potentially huge inrease in the numer of states in the NFA, and would destroy the sharing of path expressions that is a primary advantage of the NFA. Instead, we have hosen to implement prediates using a speial operator, alled Seletion, that exists outside the NFA model. We have developed two alternative approahes to implement seletion. The first approah, alled Inline, applies seletion during the exeution of the NFA, while the seond, alled SP (for seletion postponed ), simply runs the NFA as desried in the preeding setion, and then applies the seletion prediates in a post-proessing phase. Below, we disuss these two alternatives in more detail. We ompare their performane in Setion 5. We use query rewriting to ollapse adjaent // operators in to a single // operator, whih is semantially equivalent. Thus, the proess traverses at most one additional level, sine //-hild nodes do not themselves ontain a symol. 3 If prediate proessing is not needed, we an also mark the aepting state as visited to avoid proessing mathed queries more than one. 3. Implementation of the Inline Approah For the Inline approah, we extend the information stored in eah state of the NFA to inlude any prediates that are assoiated with that state, as shown in Figure 6. Sine multiple path expressions may share a state, this tale an inlude prediates from different queries. We distinguish among these y inluding a Query Id field. In a partiular Draft Sumitted for Puliation, Feruary, 00 5

6 {Q} {Q3} {Q8} QueryId PrediateId property operator value step numer property operator value Fig. 6: Prediate Storage for Inline Fig. 7: Prediate Storage for SP state, the pair (Query Id, Prediate Id) uniquely identifies a prediate. The Inline approah works as follows. When a startof-element event is reeived, the NFA transitions to new states as desried in Setion. For eah of these states, all of the prediates in the state-loal prediate tales are heked. For eah query, ookkeeping information is maintained, indiating whih of the prediates of that query have een satisfied. When an aepting state is reahed, the ookkeeping information for all of the queries of that state is heked, and those queries for whih all prediates have een satisfied are returned as mathes. There are several details to onsider with this approah, however. The first issue has to do with if and when prediate failure an redue further work. When a prediate test at a state fails, the exeution along that path annot neessarily e terminated due to the shared nature of the NFA if other queries share the state ut did not ontain a prediate that failed there, then proessing must ontinue for those queries. Furthermore, if a query ontains a // prior to a prediate, then even if the prediate fails, the query effetively remains ative due to the non-determinism introdued y that axis. For these reasons, the ommon query optimization heuristi of pushing selets to earlier in the evaluation proess in order to redue work later, is not likely to e effetive in this environment. A seond issue is that, due to the nested struture of XML douments, it is likely that aktraking will our during the NFA proessing. Suh aktraking further ompliates the task of traking whih prediates of whih query have een satisfied. For example, onsider query q= /[@f =u][@f = w]. q onsists of a single loation step with two prediates (on two different attriutes of elements). If are is not taken during aktraking, the following error ould our. Consider the XML fragment < f =u> </> < f =w> </>. When the first element is parsed the first prediate of q is set to true. When the orresponding end-of-element tag is parsed, the NFA returns to the previous state. Then, when the seond element is parsed, the seond prediate of q is marked as true. Thus, it wrongly appears that q has een satisfied. This prolem an e solved y augmenting the aktraking to inlude the undo of any hanges to prediate ookkeeping information made while proessing the state. Unfortunately, the aove solution does not solve a similar prolem that exists for reursively nested elements. For example, onsider query q when applied to the following XML fragment: < f =u> < f =w> </> </>. When the first element is parsed, the first prediate of q is set true. Before the exeution aktraks for this, another is read, whih sets the seond prediate to true, thus again, erroneously indiating that query q has een satisfied. In order to solve this latter prolem, additional ookkeeping information must e kept for prediate evaluation. This additional information identifies the partiular event that aused eah prediate to e set to True. During the final evaluation for a query at its aepting state, the query is onsidered to e satisfied only if all prediates attahed to the same loation step are satisfied y the same event. Finally, as an optimization used in our implementation of Inline, the prediates stored at a state are partitioned y property, operator and value. When an element is read, the information otained from the start-element event is used to proe the prediate tale, thus avoiding a full san of the tale. 3. Implementation of Seletion Postponed (SP) Effort spent evaluating prediates with Inline will e wasted if ultimately, the struture-ased aspets of a query are not satisfied. An alternative approah that avoids this prolem is to delay prediate proessing until after the struture mathing has een ompleted. In this approah, alled SP, the prediates are stored with eah query, as shown in Figure 7. We hose to index the prediates for a query y the field step numer, whih indiates the loation step where a prediate appears. In ontrast to Inline, using SP the exeution of struture-mathing and prediate-heking are learly Draft Sumitted for Puliation, Feruary, 00 6

7 q: a =v]// a 3 4 Runtime Stak An XML fragment: <a f a =u ><a f a =v ><></></a></a> Fig 8: A sample query, its NFA, and the NFA exeution separated. When an aepting state is reahed, seletion is performed in ulk, y evaluating all of the relevant prediates. This approah has several potential advantages. First, there is no need to extend the NFA aktraking logi as desried for Inline. Seond, sine the prediates of different loation steps are treated as onjuntions, a short-ut evaluation method is possile, where some prediate heking may e avoided for queries that are determined not to math a partiular doument. 4 In order to delay seletion until the end of struture mathing, however, the NFA must e extended to retain some additional history aout the states visited during struture mathing. The reason for this is demonstrated y the following example. Consider query q and an XML doument fragment as shown in Figure 8. When element of the doument is parsed, the NFA exeution arrives at the aepting state of the NFA for this query (also shown in Figure 8). When seletion proessing is performed for q, we need to determine whih of the two a elements enountered during parsing to test the prediate on. A naïve method would e to simply hek all of the a elements enountered. Unfortunately with more // operators in a query or more reursive elements in the doument, searhing for mathing elements for prediate evaluation ould eome as expensive as running NFA again for this query. Instead, we extend the NFA to output not only query IDs, ut a list indiating the sequenes of doument elements that would partiipate in prediate evaluation. For example in the aepting state for q, the NFA would report the sequenes a and a, where a represents the first a element and a represents the seond (nested) a element. Sine prediates are indexed y step numer, it is easy for the seletion operator to determine whih elements need to e tested. For query q, the first sequene does not satisfy the query eause a does not satisfy the prediate, ut the seond sequene does. The NFA is easily extended to output these sequenes y linking the states in the runtime stak akwards 4 Note however, that with prediate evaluation it eomes possile to visit a given aepting state multiple times, due to prediate failure and aktraking. Suh short-ut prediate evaluation only saves work for a single visit read <> math q towards the root (also as shown in Figure 8, whih inludes the ontent of the stak for the aepting state). For eah ative state that is an aepting state, we an traverse akwards to find the sequene of state visits that lead to the state. Note that elements that trigger transitions to //-hild states an e ignored in this proess, as they do not partiipate in prediate evaluation. Returning to the example in Figure 8, there are two routes, namely 3 5 and that NFA took when the path of elements a, a and were read. After eliminating the elements that trigger transitions to //- hild states for eah route, the two sequenes of mathing elements, a and a s, an e generated. 4 Performane Study of the NFA Exeution Having desried YFilter in some detail, we now turn to an investigation of its performane. We proeed in two steps. First, in this setion, we examine the performane of the NFA-ased struture mathing approah employed y YFilter in the asene of support for value-ased prediates. Here, we ompare YFilter to two alternatives: XFilter, and a hyrid approah. Then, in Setion 5, we fous on YFilter, and ompare the Inline and SP approahes to ontent-ased prediate evaluation. 4. Implementation of Alternative Approahes In order to etter understand the performane of YFilter, we implemented two alternative approahes. The first is XFilter [AF00], whih was one of the early filtering systems to represent XPath queries as FSMs and use event-ased parsing to drive their exeution. XFilter has een used as a point of omparison in several other studies (e.g. [PFL0], [CFG0], [OS0]). XFilter also served as the starting point of the work presented here. Due to spae limitations, we annot present the details of XFilter here. As an overview, XFilter works as follows: Eah query is deomposed into a sequene of loation steps and annotated with the relative distane from the previous one in terms of doument levels. These steps eome states in an FSM representing the query. Mathing parse events trigger transitions to a new state if the urrent doument level is equal to the expeted doument level of the new state. When hanging to the new state, the expeted level of the state is set using the relative distane information. To support simultaneous exeution of all FSMs, a hash tale maps element names to a list of states that are andidates for transition. When a state in a list is atually transitioned, it is deleted from the index and its suessor in the query is inserted into the orresponding entry. We implemented an improved version of XFilter, using list alaning whih was shown in [AF00] to provide signifiant performane improvements. As has een pointed out in the studies listed aove, an Ahilles heel of XFilter is that it does not support the sharing of representation or exeution among path expressions. In order to address this issue, we also implemented an improved version of XFilter, that we all Hyrid, whih does use path sharing (although not as Draft Sumitted for Puliation, Feruary, 00 7

8 aggressively as YFilter). The Hyrid approah is similar to the minimal deomposition and eager TRIE tehniques developed independently y [CPG0]. 5 Sine full path sharing requires the index sheme and exeution algorithm to handle the non-determinism introdued y and // operators, Hyrid simply deomposes queries into sustrings ontaining only /. The olletion of these sustrings is put into a single index for all queries. In addition, eah query maintains relative distane information for transitions from the end of a sustring to the start of the next sustring. During the exeution, the transition etween two states in a sustring is shared y all queries ontaining this sustring. The transition aross two sustrings is done on a per-query asis using doument level heking as XFilter. For oth XFilter and Hyrid, we added a simple optimization that is extremely important in our workloads, namely, that idential queries are represented in the system only one. We did this y pre-proessing the queries and olleting the IDs of idential queries in an auxiliary data struture. This struture is the same as that used y YFilter to manage query IDs in aepting states. 4. Experimental Set-up We implemented the three algorithms (YFilter, XFilter (with list alaning), and Hyrid) using Java. All of the experiments reported here were performed on a Pentium III 850 Mhz proessor with 384MB memory running JVM.3.0 in server mode on Linux.4. We set the maximum alloation pool of Java to 00MB, so that virtual memory and other I/O-ativity had no influene on the results. This was also verified using the Linux ommand vmstat. Following the workloads of [AF00], eah experiment was generated from a single DTD. In this setion, we fous on experiments using the NITF (News Industry Text Format) DTD [Cov99] that has een used in previous studies [AF00, CFG0]. We did however, run experiments using two other DTDs: The Xmark-Aution DTD [BCF0] from the Xmark enhmark, and the DBLP [DBL0] iliography DTD. Some harateristis of these DTDs are shown in Tale. NITF Aution DBLP # elements names # attriutes in total Tale : Charateristis of three DTDs Given a DTD, the tools used to generate an experiment inlude a DTD parser, an XML generator, a query generator and a SAX.0 [SAX0] event-ased XML parser. The DTD parser whih was developed using a WUTKA DTD parser [Wut00] outputs information on parent-hild relationships etween elements and statistis for eah element, et. whih is used y the query 5 Note that this approah was not the est performing one used in [CPG0]. However, it does provide some insight into YFilter s expeted performane relative to the other algorithms in that paper, as desried in the next setion. generator and the doument generator. We wrote a query generator, whih reads the output of the DTD parser and reates a set of XPath queries ased on the workload parameters listed in Tale. The parameters Q, D, W, and DS are relevant to the experiments in this setion. As reported in [AF00], the average length of generated queries or douments does not inrease muh when D is larger than 6, so this value was used for all experiments. For doument generation, we used IBM s XML Generator [DL99]. As a default, this generator limits the numer of times that an element an e repeated under a single parent to 3. We also used a uniform distriution to hoose among the possile elements at eah level in the doument. Pr Range Desription Q 000 to Numer of Queries D 6 fixed Maximum depth of XML douments and XPath queries. W 0 to Proaility of a wildard ourring at a loation step DS 0 to Proaility of // eing the operator at a loation step P 0 to 0 Numer of prediates per query (avg.) Tale : Workload Parameters For eah DTD we generated a set of 00 XML douments. All reported experimental results are averaged over this set. For eah experiment, queries were generated aording to the workload setting. For eah algorithm, queries were preproessed, if neessary, and then ulk loaded to uild the index and other data strutures. Then XML douments were read from disk one after another. The exeution for eah doument returned a it set, eah it of whih indiates whether or not the orresponding query has een satisfied. For eah experiment run of an algorithm (i.e., 00 douments) we egan a new proess, to avoid ompliations from Java s garage olletor. Previous work [AF00, CFG0] used filtering time as the performane metri, whih is the total time to proess a doument inluding parsing and outputting results. Notiing that java parsers have varying parsing osts, we instead report on a slightly different performane metri we all multi-query proessing time (MQPT). MQPT is simply the filtering time minus the doument parsing time. MQPT onsists of two primary omponents: path navigation and result olletion. The latter is the ost to ollet the identifiers of queries from the auxiliary data strutures and to mark them in the result it set. We measured these osts separately. Where appropriate, we also report on other metris suh as the numer of transitions followed, the size of the various mahines, and the osts assoiated with maintenane, et. 4.3 Effiieny and Salaility Having desried our experimental environment, we egin our disussion of experimental results y presenting Draft Sumitted for Puliation, Feruary, 00 8

9 MQPT (ms) yfilter hyrid xfilter(l) "//" Proaility Fig. 9: Varying numer of queries (NITF, D=6, W=0., DS=0.) Fig. 0: Varying numer of queries (Aution, D=6, W=0., DS=0.) Fig. : Varying // proaility (NITF, Q=500000, D=6, W=0) the MQPT results for the three alternatives as the numer of queries in the system is inreased Experiment : NITF. Figure 9 shows the MQPT for the three algorithms as the numer of queries in the system is inreased from 000 to 500,000, under the NITF workload, with the proaility of and // operators eah set to 0.. With this setting, there is approximately one operator and one // operation in eah query. For eah data point the ars represent, from left to right: YFilter, Hyrid, and XFilter. As an e seen in the figure, YFilter provides the signifiantly etter performane than the other two aross the entire range of query populations. XFilter is the slowest here y far, and not surprisingly, Hyrid s performane lies etween the two. In the figure, MQPT is split into its omponent osts: path navigation and result olletion. In terms of path navagation, YFilter exhiits a ost of around 0 ms when Q is larger than 50,000. In ontrast, the navigation ost of XFilter inreases dramatially as Q inreases, to 633 ms at 500,000, while Hyrid takes 38 ms at this point. Thus Yfilter exhiits an order of magnitude improvement for path navigation over these other shemes. 6 The performane enefits of YFilter ome from two fators. The first is the enefit of shared work otained y the NFA approah. The seond is the relatively low ost of state transition in YFilter (ompared to the others) that results from the hash-ased implementation desried in Setion. The levelling off of YFilter s navigation time (in fat, all of the approahes show some degree of this) is explained y Tale 3, whih shows the numer of distint queries in the system for inreasing values of Q in this experiment. While all of the systems an exploit ompletely idential queries, YFilter is the most suessful among the three at exploiting ommonality 6 Reall that our Hyrid approah is similar to the Eager Trie proposed in [CFG0]. The fastest algorithm studied there, alled Lazy Trie was shown to have aout a 4x improvement over XFilter when used with a numer of distint queries similar to what arises with Q= 500,000 here. among similar, ut not exatly idential queries (reall, that all ommon prefixes of the paths are shared). Q (xk) #. distint queries (xk) Tale 3: Numer of Distint Queries as Q Inreases (NITF, D=6, W=0., DS=0.) In this experiment, the MQPT of YFilter is dominated y the ost of result olletion when Q is larger than 300,000. Although we oded result olletion arefully, we elieve that it an e sped up somewhat. However, when doument parsing time is also onsidered, it is eomes lear YFilter s performane in this ase is suh that any further improvements in path navigation time will have at est, a minor impat on overall performane. The Xeres [Apa99] parser we used, set in a nonvalidating mode, took 68 ms on the average to parse a doument. It ompletely dominated the NFA-ased exeution. We tried other pulily availale java parsers inluding Java XML Pak [JXP0] and Saxon XSLT proessor [Kay0] supporting SAX.0 [SAX0]. Saxon gave the est performane at 8 ms, still sustantially more the NFA navigation ost. We have also experimented with C++ parsers, whih are muh faster, ut even with these parsers we would expet parsing time to e similar to the ost of path navigation with YFilter, partiularly if YFilter were also implemented in C++! 4.3. Experiment : Other DTDs As stated aove, we also ran experiments using two other DTDs. Spae preludes us from desriing these results in detail, so we summarize them here. Figure 0 shows the MQPT results otained for the three algorithms using the same parameter settings as in the previous experiment, ut with the Xmark-Aution DTD. As an e seen in the figure, the trends oserved using NITF are also seen here: YFilter performs sustantially etter than the other two for all Q values tested. This DTD differs from NITF in that due to its struture, it tends to generate longer douments (on Draft Sumitted for Puliation, Feruary, 00 9

10 average 70 start-end element pairs, 3.5 times as that of NITF). Thus all algorithms take longer to filter the douments here. XFilter, however, is partiularly sensitive to the length of douments eause its FSM representation and exeution algorithm ause signifiant memory management overhead, whih in turn invokes garage olletion muh more frequently. The results otained using the DBLP DTD also told a similar story, ut the differenes were not as great due to the small douments and queries it generates. Details are omitted due to spae limitations. 4.4 Experiment 3: Varying the Non-determinism The proaility of // operators and operator determine the omplexity of proessing of path expressions. Their impat on the performane of the algorithms is studied in this susetion. We used NITF in all the following experiments. The MQPT was first measured with proaility set to zero and // proaility varied from 0 to. The results for Q=500,000 are shown in Figure. As an e seen in the figure, XFilter is extremely sensitive to this parameter, while Hyrid is less so. YFilter shows very little sensitivity. These results are driven largely y the effet of // proaility on the numer of distint queries, and the sensitivity of the algorithms to that fator. The effet of inreasing // proaility on the numer of distint queries is two-fold, as shown in Tale 4. When the proaility is elow 0.5, the // operators our more in queries, yielding a growing numer of distint queries. When it is larger than 0.5, most operators for loation steps are //, resulting in the dereasing numer of distint queries. Note that there are fewer distint queries when the proaility equals 0 (only / operators) than when it equals (only // operators). This is eause every query starts from the root element in the former ase, while a query an start at any level in the latter ase. // proaility No. of distint queries (xk) Tale 4: Numer of Distint Queries as Q inreases (NITF, D=6, Q=500000, W=0) It is interesting to note that when // proaility is 0, Hyrid is idential to YFilter eause there is no deomposition of queries. As the proaility inreases from 0 to, it keeps up with XFilter. At DS =, every query is deomposed into single elements and its performane is very lose to XFilter. We also ran an experiments varying the proaility of operator and the results were similar. Sine operators have a smaller effet on the numer of distint queries, the differene among algorithms was somewhat less pronouned. 4.5 Experiment 4: Maintenane ost The last set of experiments we report on in this setion deal with the ost of maintaining the YFilter struture, whih is expeted to e one of the primary enefits of the approah. Updates to the NFA in YFilter are handled as follows: To insert a query, we merge its NFA representation with the omined NFA as desried in Setion.. To delete a query, the aepting state of the query is loated and the query s identifier is deleted from the list of queries at this state. If the list eomes empty and the state does not have a hild state in the NFA, the state is deleted y removing the link from its parent. The deletion of this state an e propagated to its predeessors. An update to a query is treated as a delete of the old query followed y the insertion of the new one. Deletion may e ineffiient eause of modifiation of the list at the aepting state and the deletion of states. As demonstrated in the previous setions, YFilter s performane is fairly insensitive to the numer of queries in the system. Thus, instead of deleting queries immediately, we an adopt a lazy approah where a list of deleted queries is maintained. This list is used to filter out suh queries efore results are returned. The atual deletions an then e done asynhronously. Thus, in this setion we fous on the performane of inserting new queries. We measured the ost of inserting 000 queries varying numers of queries already in the index. With Q = 000 (i.e., 000 queries already in the NFA), it takes 80 ms to insert the new queries. At this point, the hane of a query eing new is high, requiring new states to e reated and transition funtions to e expanded y adding more hash entries to the states. However, the ost drops dramatially as more queries are added to the system. Beyond Q=0,000, the insertion ost remains onstant within 5 to 6 ms. This is eause most path expressions, are already present in the index, so inserting a new query often requires only the traversal down a single path to an existing aepting state, and the insertion of a new query ID into the list kept at that state. Thus, the NFA-ased struture requires a very low maintenane overhead one a reasonale numer of queries exist in the system. 5 Experiments on Seletion Having shown the effiieny of NFA-ased struture mathing, we now turn to our two approahes to integrating ontent-ased prediate proessing. The NITF DTD was used for all experiments presented in the setion. XML douments are generated with element data and attriutes using statistis otained from the DTD parser. The statistis for eah element inlude the maximum numer of values the element an take, the proaility of an attriute ourring in the element and the maximum numer of values an attriute an take. All proailities were hosen uniformly etween 0 and. The maximum numer of values for elements and attriutes was hosen uniformly etween and 0. The XML generator was then extended to generate douments with data values and attriutes aording to these proailities. For query generation, the parameter P (see Tale ) was used to determine the average numer of prediates Draft Sumitted for Puliation, Feruary, 00 0

11 MQPT (ms) Inline(P=) 3000 Inline(P=) 500 SP(P=) SP(P=) No. of Queries (xk) MQPT (ms) Inline 500 SP No. of Prediates Per Query MQPT (ms) 350 SP 300 SP+sorting No. of Prediates Per Query Fig. : Varying numer of queries (D=6, W=0., DS=0.) Fig. 3: Varying numer of prediates (D=6, Q=50000, W=0., DS=0.) Fig. 4: Effet of prediate sorting (D=6, Q=50000, W=0., DS=0.) that appear in eah query. Suh prediates are distriuted among the loation steps with uniform proaility. In the following experiments, P varies from 0 to 0. Note that the addition of prediates to the queries makes the queries sustantially more seletive than they were in the experiments desried in the previous setion. Also, suh prediates make the ourrene of exatly idential queries muh less likely (although the proaility of strutural equivalene remains the same as in the experiments of the previous setion). 5. Experiment 5: Effiieny and Salaility In this experiment we examined the relative performane of Inline and SP as the numer of queries is varied from,000 to 500,000. Figure shows the MQPT of the two approahes for the ases P= and P=. Note that When P=,.5% of queries on the average were satisfied y a doument. When P=, 3.% of the queries were satisfied. As an e seen in the figure, SP outperforms Inline y a wide margin. When P=, for example, SP runs 3.8 times faster than Inline when Q=00,000, and 4.4 times as faster when Q=400,000. Inline suffers from the osts of unneessary and repeated prediate evaluation (as desried in Setion 3) as well as from the overhead of maintaining the ookkeeping information in evaluation data strutures. This extra overhead auses Inline to run out of memory in this ase, for Q = 400,000 and aove. When the numer of prediates per query is douled (P=, also shown in Figure ) the differenes etween the two approahes are even more pronouned. In this ase, SP runs 4. times faster than Inline when Q=00,000, and Inline runs out of memory with roughly half as many queries as when P=. Figure 3 shows the MQPT of the two approahes as the numer of prediates per query is varied from 0 to 0 for a relatively small numer of queries (Q =50,000). As an e seen in the figure, SP is muh less sensitive to the numer of prediates per query than Inline. This is eause of SP s lower overhead and its aility to avoid many of the unneessary prediate evaluations performed y Inline. When omparing these results with those of the previous experiments, it is important to note that for YFilter, the ost of ontent-ased mathing an easily dominate the ost of struture mathing. 5. Experiment 6: Prediate Sorting The previous experiment demonstrated the enefits of delaying ontent-ased mathing in YFilter. One of the major enefits was seen to e the aility to short-ut the evaluation proess for a query when one prediate fails. This oservation raises the potential to further improve the hanes of suh short-ut evaluation y modifying the order of prediate heking to evaluate highly-seletive prediates first, as is done y most relational query optimizers. The seletivity of prediates on element data or on element position an e estimated from the numer of their possile values. Estimating seletivity of prediates on attriutes requires additional information on the proaility of an attriute ourring. Some examples of equality prediates on these properties for a loation step on an element a are given as follows: Sel([@attr]) = proaility of the attriute ourring in element a. Sel([@attr= v ]) = Sel[@attr] / max. no. of values attriute attr an take Sel([.= v ]) = / max. no. of values element a an take. The seletivity estimates for prediates involving other omparison operators an e derived in a similar way. Having a wildard in a loation step requires using some averaged statistis. Other formulas are omitted here due to spae onstraints. We performed a simple experiment to examine the potential performane enefits of prediate reordering in the SP approah. In this experiment, we sorted prediates in asending order of seletivity for eah query. Figure 4 shows the MQPT for SP with and without sorting, as P is varied from 0 to 0 for Q=50,000. The results (shown in Figure 4) indiate that as expeted, additional enefits an indeed e gained y prediate sorting, partiularly for ases with large numers of prediates. 6 Related Work As disussed in the introdution, previous work on XML filtering, while often supporting oth struture-ased and ontent-ased mathing, has not diretly addressed the interation etween these two very different proesses. In addition to this work, a numer of other efforts are related to the work desried here. Draft Sumitted for Puliation, Feruary, 00