XML Stream Processing

1. XML Stream Processing Yanlei Diao University of Massachusetts Amherst

2. XML Data Streams • XML is the “wire format” for data exchanged online. • Purchase orders http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=ubl • News feeds http://blogs.law.harvard.edu/tech/rss • Stock tickers http://www.tickertech.com/products/xml/ • Transactions of online auctions http://bigblog.com/online_auctions.xml • Network monitoring data http://ganglia.sourceforge.net/ Yanlei Diao, University of Massachusetts Amherst

3. XML Stream Processing • XML data continuously arrives from external sources, queries are evaluated every time a new data item is received. • A key feature of stream processing is the ability to process as it arrives. • Natural fit for XML message brokering and web services where messages need to be filtered and transformed on-the-fly. • XML stream processing allows query execution to start before a message is completely received. • Short delay in producing results. • No need to buffer the entire message for query processing. • Both are crucial when input messages are large, e.g. the equivalent of a database’s worth of data. Yanlei Diao, University of Massachusetts Amherst

4. Event-Based Parsing • XML stream processing is often performed on the granularity of an XML parsing event produced by an event-based API. < Start Document < Start Element: report < Start Element: section < Start Element: title Characters: Pub/Sub > End Element: title < Start Element: section < Start Element: figure < Start Element: title Characters: XML Processing > End Element: title > End Element: figure > End Element: section … > End Element: section > End Element: report > End Document <?xml version="1.0" ?> <report> <section id=“intro” difficulty=“easy”>  <title>Pub-Sub</title>  <section difficulty=“easy”>  <figure source=“g1.jpg”> <title>XML Processing</title> </figure>  </section> <figure source=“g2.jpg”> <title>Scalability</title> </figure> </section> </report> Yanlei Diao, University of Massachusetts Amherst

5. Matching a Single Path Expression XFilter [Altinel&Franklin’00], YFilter [Diao et al.’02], Tukwila [Ives et al.’02] • Simple paths: ( (“/” | “//”) (ElementName | “*”) )+ • A simple path can be transformed to a regular expression • Let  = set of element names: • ‘/’ is translated to the ‘·’ concatenation operator • “//” is translated to * • ‘*’ is translated to  • “/a//b” can be translated to “a * b” • A finite automaton (FA) for each path: mapping location steps to machine states. Yanlei Diao, University of Massachusetts Amherst

6. /a /* //a a a * a b b a    * * * Query Compilation Map location steps to automaton fragments For multi-path processing; o.w. not needed Location steps Automaton fragments Concatenate automaton fragments for location steps in a query Query “/a//b” Is this Automaton deterministic or non-deterministic? Yanlei Diao, University of Massachusetts Amherst

7. section  figure * Event-Driven Query Execution < Start Document < Start Element: report < Start Element: section < Start Element: title Characters: Pub/Sub > End Element: title < Start Element: section < Start Element: figure < Start Element: title Characters: XML Processing > End Element: title > End Element: figure > End Element: section … > End Element: section > End Element: report > End Document • Query execution retrieves all matches of a path expression. • Event-driven execution of FA: • Parsing events (esp. start of elements) drive the FA execution. • Elements that trigger transitions to the accepting states are returned. • Run FA over XML with nested structure, retrieve all results • Approach 1: shred XML into a set of linear paths • Approach 2: augment FA execution with backtracking Yanlei Diao, University of Massachusetts Amherst

8. Multi-Query Processing • Problem: evaluate a set Q = Q1, …, Qn of path queries against each incoming XML document. • Brute force: iterate the query set, one query at a time • Indexing of queries: inverse problem of traditional query processing • Traditional DB: Data is stored persistently; queries executed against the data. Indexes of data enable selective searches of the data. • XML stream processing: Queries are persistently stored; documents or their parsing events drive the matching of queries. Indexes of queries enable selective matching of documents to queries. • Sharing of processing: commonalities exist among queries. Shared processing avoids redundant work. Yanlei Diao, University of Massachusetts Amherst

9. c {Q1} {Q3, Q8} {Q3} b {Q2} {Q4} c c a a * b  c {Q6} * {Q5} c {Q7} * c Constructing the Combined FSM YFilter [Diao et al.’03] builds a combined FA for all paths. • Complete prefix sharing among paths. • Moore machine with output: accepting states → partition of query ids. • Nondeterministic Finite Automaton (NFA)-based implementation: a small machine size, flexible, easy to maintain, etc. Q1=/a/b Q5=/a/*/b Q6=/a//c Q2=/a/c Q7=/a/*/*/c Q3=/a/b/c Q4=/a//b/c Q8=/a/b/c Yanlei Diao, University of Massachusetts Amherst

10. {Q1} c 5 10 12 {Q3, Q8} 9 7 6 6 8 11 b 3 5 3 9 7 6 {Q2} {Q4} c 2 4 1 read <b> a b 8 7  2 match Q1 1 read <c> 6 11 match Q3Q8 {Q6} * Q5 Q4 Q6 10 9 {Q5} c 12 13 * {Q7} * c An XMLfragment <b> <c> </c> … <a> c c 3 3 9 7 6 2 2 2 1 1 1 1 initial read <a> read </c> Execution Algorithm YFilter uses a stack mechanism to handle XML. • Backtracking in the NFA. • No repeated work for the same element. Runtime Stack NFA <b> <c> </c> Yanlei Diao, University of Massachusetts Amherst

11. O(3nm) O(3n) YFilter specific Implementation Choices • Non-Deterministic Automata (NFA) versus Deterministic Automata (DFA) • NFA: small machine, large numbers of transitions per element • DFA: potentially large machine, one transition per element • Worse-case comparison for regular expressions: • Restricted path expressions: Possible in practice? Yanlei Diao, University of Massachusetts Amherst

12. Eager DFA • Green et al. studied the size of DFA for the restricted set of path expressions [Green et al.’03] • Eager DFA: • Query compile time, translates from NFA to DFA • Creates a state for every possible situation that runtime may require • Single path: • Linear for “//e1/e2/e3/e4/e5” • Exponential for “//e1/*/*/*/e5” • Multiple paths: • Exponential for “//e1//b”, “//e2//b”, …, “//e5//b” Yanlei Diao, University of Massachusetts Amherst

13. Example of an Eager DFA //a/*/*/c/d “a a b b c d” “a b a b c d” Need to remember all the A’s in three consecutive characters, as different combinations of As may yield different results. The DFA size is O(2w+1) where w is the number of ‘*’. Yanlei Diao, University of Massachusetts Amherst

14. Lazy DFA • Lazy DFA is constructed at run time, on demand • Initially, it has a single state • Whenever it attempts to make a transition into a missing state, it computes it and updates the transition • Hope: only a small set of the DFA states is needed. • Exploits DTD to derive upper bounds… Yanlei Diao, University of Massachusetts Amherst

15. Lazy DFA (contd.) • A DTD graph is simple, if the only loops are self-loops. • Theorem: the size of a lazy DFA is exponential only in the maximal number of simple cycles a path can intersect. • Not exponential in # of paths! DTD graph • More complex recursive DTDs: e.g. “table” contains “list” and “list” contains “table” • Even a lazy DFA grows large… Yanlei Diao, University of Massachusetts Amherst

16. Predicates in Path Expressions • Predicates can address attributes, text data, or positions of elements. • Value of an attribute in an element, e.g., //section[@difficulty = “easy”]. • Text data of an element, e.g., //section/title[text()=“XPath”]. • Position of an element, e.g., //section/figure[text()=“XPath”][1]. Yanlei Diao, University of Massachusetts Amherst

17. Predicate Evaluation • Extend the NFA • including additional states representing successful evaluation of predicates and transitions to them • Potential problems • A potentially huge increase in the machine size • Destroy sharing of path expressions • Recent work[Gupta & Suciu 2003]:Possible to build an efficient pushdown automaton using lazy construction if • No mixed content, such as “<a> 1 <b> 2 </b> </a>”. • Can afford to periodically rebuild the automaton from scratch. • Can afford to train the automaton in each construction. Yanlei Diao, University of Massachusetts Amherst

18. 2 4 5 2 section Shared Path Matching Engine 1 7 {P1} {P2} figure report figure figure  2 4 5 5 3 section 4 8 2 7 section title * section  title 5 parsing events * figure 6 title YFilter: Mapping XML to Relational • XQuery is much more complex than regular expressions. • Leverage efficient relational processing • XQuery stream processing = relational operations on pathtuple streams! P2: //section/section/figure P1: //section//figure path-tuple streams Yanlei Diao, University of Massachusetts Amherst

19. OuterJoin-Select   ΠDupElim ΠDupElim ΠDupElim F W1 W2 R1 R2 Example Query Plan for FWR Q1: for$sin $doc//section[@difficulty=“easy”] where$s/title = “Pub/Sub” and$s/figure/title = “XML processing” return<section> { $s//section//title } { $s//figure } </section> F://section W1://section/title W2://section/figure/title R1://section//section//title R2://section//figure    Push all paths into the path engine. An external (post-processing) plan for each query: • Selection: evaluates value-based predicates. • Projection: projects onto specific fields and removes duplicates. • Semijoin: handles correlations between for and where paths, finds query matches. • Outerjoin-Select: handles correlations between for and return paths, generates query results. Shared Path Matching Engine Yanlei Diao, University of Massachusetts Amherst

20. Buffering in XML Stream Processing • Buffering in XQuery stream processing • Whether an element belongs to the result set is uncertain as it depends on predicates that have not been evaluated • Goal:avoid materialization and minimize buffering • Issues to address: • What queries require buffering? • What elements to buffer? • When and how to prune dynamic data structures? • Buffered elements • State in any dynamic data structures Yanlei Diao, University of Massachusetts Amherst

21. 2 @id=“intro” section 1 7 @difficulty=“easy” figure report 3 4 8 @source=“g2.jpg” title “Pub/Sub” section title @difficulty=“easy” 5 figure “Scalability” @source=“g1.jpg” 6 title “XML processing” Buffering in XML Stream Processing //section[title=“XML”] • Requires buffering? • Yes • What element to buffer? • section • When to prune? • until the end of section is encountered, or • when no more title can occur in this section. (Use DTD!) Yanlei Diao, University of Massachusetts Amherst

22. 2 @id=“intro” section 1 7 @difficulty=“easy” figure report 3 4 8 @source=“g2.jpg” title “Pub/Sub” section title @difficulty=“easy” 5 figure “Scalability” @source=“g1.jpg” 6 title “XML processing” Buffering in XML Stream Processing //section[figure=“XML”]/title • Requires buffering? • Yes • What element to buffer? • title • When to prune? • until a figure matches the predicate, or • when no more figure can occur in this section (use DTD!), or • the end of section is encountered. Yanlei Diao, University of Massachusetts Amherst

23. 2 @id=“intro” section 1 7 @difficulty=“easy” figure report 3 4 8 @source=“g2.jpg” title “Pub/Sub” section title @difficulty=“easy” 5 figure “Scalability” @source=“g1.jpg” 6 title “XML processing” Buffering in XML Stream Processing //section[contains(.//title, “XML”)]//figure • Requires buffering? • Yes • What element to buffer? • figure • figure5?, figure7? • When to prune? • until the predicate is true, or • when no more title can occur in this section (use DTD!), or • the end of section is encountered. Yanlei Diao, University of Massachusetts Amherst

24. Yanlei Diao, University of Massachusetts Amherst

25. XQuery Usage Scenarios • XML message brokers • Simple path expressions, for authentication, authorization, routing, etc. • Single input message, relatively small • Transient and streaming data (no indexes) • XML transformation language in Web Services • Large and complex queries, mostly for transformation • Input message + external data sources, small/medium sized data sets (xK -> xM) • Transient and streaming data (no indexes) • Semantic data verification • Mostly messages • Potentially complex (but small) queries • Streaming and multi-query optimization required Yanlei Diao, University of Massachusetts Amherst

26. Example 2 of an Eager DFA //a/b//c/d //e/f//g/h If there are l patterns with “//” per pattern, we need O(2^l) states to record the matching of the power set of the prefixes. The DFA size is O((x+1)l), where x is the number of “//” per pattern, and l is the number of patterns. Yanlei Diao, University of Massachusetts Amherst

27. Full XQuery Stream Processor • Stream processing for the entire XQuery language [Daniela et al.’04] • General algebra for XQuery • Pull-based token-at-a-time execution model • Lazy evaluation (like other functional languages) • Some preliminary work on sharing [Diao et al.’04] • Buffering is a big concern [Barton et al.’03, Peng&Chawathe’03, Koch et al.’04] • Sharing is crucial for performance and scalability for large numbers of queries Yanlei Diao, University of Massachusetts Amherst