1. Indexing and Querying XML Data for Regular Path Expressions Quanzhong Li and Bongki Moon Dept. of Computer Science University of Arizona VLDB 2001.

2. Querying XML XML has tree structured data model. Queries involve navigating data using regular path expressions.(e.g., XPath) e.g. /chapter/-*/figure[@caption=“Tree Frogs”] Accessing all elements with same name string. Ancestor-descendant relationship between elements.

3. Contribution New system for Indexing XML data. Querying XML data based on a numbering scheme for elements Join algorithms for processing complex regular path expressions.

4. Outline Numbering scheme Index structure Join algorithms Experimental results

5. Path expression evaluation Previous approaches Conventional tree traversals  Disadvantage: Overhead of traversing for long or unknown path lengths. New approach Indexing for efficient element access. Numbering scheme for ancestor- descendant relationship.

6. Dietz’s Numbering Scheme for two given nodes x and y, x is an ancestor of y, if and only if x occurs before y in the preorder traversal of T and after y in postorder traversal. (1,7) (2,4) (3,1) (4,2) (5,3) (6,6) (7,5)

7. Proposed numbering scheme This associates with each node a pair of numbers as follows: For a tree node y and its parent x, order(x) < order(y) order(y)+size(y) =< order(x) + size(x) For two sibling nodes x and y, if x is the predecessor of y in preorder traversal then order(x) + size(x) < order(y) (1,100) (10,30) (11,5) (17,5) (25,5) (41,10) (45,5)

8. Advantages Efficient Updates Extra space can be reserved to accommodate future insertions.

9. Ancestor–descendant relationship For two given nodes x and y of a tree T, x is an ancestor of y if and only if order(x) < order(y) =< order(x) + size(x).

10. Outline Numbering scheme Index structure Join algorithms Experimental results

11. Index and Data Organization XML Raw Data Document Loader Element Index Attribute Index Structure Index Name Index Value Table Paged File Query Processor Query XISS Result

12. Element Index Element nid Document ID list Element list with the Same name in the Same Document B+-tree Depth, Parent ID Element Record Element nid B+-tree

13. Structure Index Document ID (did) Array of All Elements And Attributes in the Same Document nid,, Parent order, Child order, Sibling order, Attribute order B+-tree

14. Outline Numbering scheme Index structure Join algorithms Experimental results

15. Regular Path expression complex regular path expressions. e.g., /chapter/_*/figure[@caption=“Tree Frogs”] SymbolFunction of symbol __Any single node /Union of node *Zero or more occurrences of a node @Denotes attributes

16. Regular expression Decomposition A regular path expression can be decomposed to a combination of following basic subexpressions: 1. A subexpression with a single element or a single attribute, 2. A subexpression with an element and an attribute ( e.g., figure[@caption = “Tree Frogs”]) 3. A subexpression with two elements (e.g., chapter/figure or chapter/_*/figure), 4. A subexpression with a Kleene closure (+,*) of another subexpression, and 5. A subexpression that is a union of two other subexpressions.

17. Example ( E1 / E2 ) * / E3 / ( ( E4 [ @A = v ] ) | ( E5 / _* / E6 ) ) * [ ] E1 E2E3E4@A=vE5E6 / / / / /_*/EE-Join KC-Join EE-Join Union EA-JoinEE-Join

18. Join algorithms Element – Attribute join Element – Element join Kleene – Closure join

19. EA-Join Algorithm Input: {E1..Em}: Ei is a set of elements having a common document identifier; {A1..An}: Aj is a set of attributes having a common document identifier; Output: A set of (e,a) pairs such that the element e is the parent of the attribute a. //Sort-merge {Ei} and {Aj} by document identifier. For each Ei and Aj with the same did do //Sort-merge Ei and Aj by PARENT-CHILD relationship. For each e in Ei and a in Aj do If ( e is a parent of a) then output (e,a); End End.

20. Example chapter appendix Figure book

21. Attribute-element position chapter name chapter name chapter name

22. EE-Join Algorithm Input: {E1..Em} and {F1..Fn}: Ei and Fj is a set of elements having a common document identifier. Output: A set of (e,f) pairs such that the element e is an ancestor of the element f. //Sort-merge {Ei} and {Fj} by doc. identifier. For each Ei and Fj with the same did do //Sort-merge Ei and Fj by ANCESTOR-DESCENDANT relationship. For each e in Ei and f in Fj do If (e is an ancestor of f ) then output (e,f) End

23. Extreme case of EE-Join chapter figure

24. KC-Join Algorithm Input: {E1..Em}: where Ei is a group of elements from an XML document. Output: A Kleene Closure of {E1..Em} //Apply EE-Join algorithm repeatedly. Set x = 1; Set Ki = {E1..Em}; Repeat Set I = I +1; Set Ki = EE-Join(Ei-1, E1); Until ( Ki is empty); Output union of K1,K2..Ki-1.

25. Outline Numbering scheme Index structure Join algorithms Experimental results

26. Experiment Results Comparison with top-down and bottom- up evaluation methods. Comparison for EE-Join ( E1 /_*/ E2 ) EA-Join ( E[@A] ) Scalability test

27. EE-Join performance

28. EA-Join performance

29. Results EE-Join algorithm outperformed bottom-up. EA-Join algorithm is comparable with top-down but outperformed bottom-up. Both are linearly scalable.