1. 1 Introduction To XML Algebra Wan Liu Bintou Kane Advanced Database Instructor: Elka 2/11/2002 1

2. 2 Outline Reasons for XML algebra Niagara algebra AT&T Algebra

3. 3 Data Model and Design We need a clear framework to design a database A data model is like creating different data structures for appropriate programming usage. It is a type system, it is abstract. Relational database is implemented by tables, XML format is a new one method for information integration.

4. 4 Why XML Algebra? It is common to translate a query language into the algebra. First, the algebra is used to give a semantics for the query language. Second, the algebra is used to support query optimization.

5. 5 XML Algebra History Lore Algebra (August 1999) -- Stanford University IBM Algebra (September 1999) --Oracle; IBM; Microsoft Corp YAT Algebra (May 2000) AT&T Algebra (June 2000) --AT&T; Bell Labs Niagara Algebra (2001) -- University of Wisconsin -Madison

6. 6 NIAGARA Title : Following the paths of XML Data: An algebraic framework for XML query evaluation By : Leonidas Galanis, Efstratios Viglas, David J. DeWitt, Jeffrey. F. Naughton, and David Maier.

7. 7 OutLine Concepts of Niagara Algebra Operations Optimization

8. 8 Goals of Niagara Algebra Be independent of schema information Query on both structure and content Generate simple,flexible, yet powerful algebraic expressions Allow re-use of traditional optimization techniques

9. 9 Example: XML Source Documents Invoice.xml 2 AT&T $0.25 1 Sprint $1.20 1 AT&T $0.75 Customer.xml 1 Tom 2 George

10. 10 XML Data Model and Tree Graph Example: Invoice_Document Invoice … number carrier total number carrier total 2 AT&T$0.251 Sprint $1.20 2 Sprint $0.25 1 Sprint $1.20 Ordered Tree Graph, Semi structured Data

11. 11 XML Data Model [GVDNM01] Collection of bags of vertices. Vertices in a bag have no order. Example: Root invoice.xml invoice invoice.account_number Invoice-element-content element-content [Root “invoice.xml ”, invoice, invoice. account_number ]

12. 12 Data Model Bag elements are reachable by path expressions. The path expression consists of two parts : An entry point A relative forward part Example: account_number:invoice

13. 13 Operators Source S, Follow , Select , Join, Rename , Expose , Vertex, Group , Union , Intersection , Difference -, Cartesian Product .

14. 14 Source Operator S Input : a list of documents Output :a collection of singleton bags Examples : S (*) All Known XML documents S (invoice*.xml) All XML documents whose filename matches “invoice*.xml S (*,schema.dtd) All known XML documents that conform to schema.dtd

15. 15 Follow operator  Input : a path expression in entry point notation Functionality : extracts vertices reachable by path expression Output : a new bag that consist of the extracted vertex + all the contents of the original bag (in care of unnesting follow)

16. 16 Follow operator (Example*) Root invoice.xml invoice Invoice-element-content Root invoice.xml invoice invoice.carrier Invoice-element-content carrier -element-content  (carrier:invoice) *Unnesting Follow {[Root invoice.xml, invoice]} {[Root invoice.xml, invoice, invoice.carrier]}

17. 17 Select operator  Input : a set of bags Functionality : filters the bags of a collection using a predicate Output : a set of bags that conform to the predicate Predicate : Logical operator (,,), or simple qualifications (,,,,,)

18. 18 Select operator (Example)  invoice.carrier =Sprint Root invoice.xml invoice Invoice-element-content Root invoice.xml invoice Invoice-element-content Root invoice.xml invoice Invoice-element-content {[Root invoice.xml, invoice], [Root invoice.xml, invoice], ……………} {[Root invoice.xml, invoice],… }

19. 19 Join operator Input: two collections of bags Functionality: Joins the two collections based on a predicate Output: the concatenation of pairs of pages that satisfy the predicate

20. 20 Join operator (Example) Root invoice.xml invoice Invoice-element-content Root customer.xml customer customer-element-content account_number: invoice =number:customer Root invoice.xml invoice Root customer.xml customer Invoice-element-content customer-element-content {[Root invoice.xml, invoice]}{[Root customer.xml, customer]} {[Root invoice.xml, invoice, Root customer.xml, customer]}

21. 21 Expose operator  Input: a list of path expressions of vertices to be exposed Output: a set of bags that contains vertices in the parameter list with the same order

22. 22 Expose operator (Example) Root invoice.xml invoice. bill_period invoice.carrier carrier-element-content bill_period -element-content  (bill_period,carrier) {[Root invoice.xml, invoice.bill_period, invoice.carrier]} Root invoice.xml invoice invoice.carrier invoice.bill_period Invoice-element-content bill_period -element-content {[Root invoice.xml, invoice, invoice.carrier, invoice.bill_period]} carrier-element-content

23. 23 Vertex operator Creates the actual XML vertex that will encompass everything created by an expose operator Example : (Customer_invoice)[  ( (account)[invoice.account_number], (inv_total)[invoice.total])]

24. 24 Other operators Group  : is used for arbitrary grouping of elements based on their values Aggregate functions can be used with the group operator (i.e. average) Rename  : Changes the entry point annotation of the elements of a bag. Example: (invoice.bill_period,date)

25. 25 Example: XML Source Documents Invoice.xml 2 AT&T $0.25 1 Sprint $1.20 1 $0.75 maria Customer.xml 1 Tom 2 George

26. 26 Xquery Example List account number, customer name, and invoice total for all invoices that has carrier = “Sprint”. FOR $i in (invoices.xml)//invoice, $c in (customers.xml)//customer WHERE $i/carrier = “Sprint” and $i/account_number= $c/account RETURN $i/account_number, $c/name, $i/total

27. 27 Example: Xquery output 1 Tom $1.20

28. 28 Algebra Tree Execution customer (2)customer(1)Invoice (1)invoice (2)invoice (3) Source (Invoices.xml)Source (cutomers.xml) Follow (*.invoice)Follow (*.customer) Select (carrier= “Sprint” ) invoice (2) Join (*.invoice.account_number=*.customer.account) invoice(2) customer(1) Expose (*.account_number, *.name, *.total ) Account_number name total

29. 29 Optimization with Niagara Optimizer based on the Niagara algebra Use the operation more efficiently Produce simpler expression by combining operations

30. 30 Language Convention A and B are path expressions A< B --  Path Expression A is prefix of B AnB ---  Common prefix of path A and B AńB ---  Greatest common of path A and B ┴ ---  Null path Expression

31. 31 Use of Rule 8.5 Make profit of rule 8.5 Allows optimization based on path selectivity When applying un-nesting follow operation Φ μ

32. 32 Φ μ (A) [Φ μ (B)]=Φ μ (B)[Φ μ (A)] True When Exist C / C <A && C < B C = AńB Or AnB = ┴ Interchangeability of Follow operation

33. 33 Application of 8.5 With Invoice Φ μ (acc_Num:invoice)[Φ μ (carrier:invoice)] * ?= Φ μ (carrier:invoice)[Φ μ (acc_Num:invoice)] ** Both Share the common prefix invoice Case AńB = invoice

34. 34 Benefit of Rule Application Note if: acc_Num required for each invoice Element carrier is not required for invoice Element Then using * Φ μ (acc_Num:invoice)[Φ μ (acc_Num:customer)] make more sense than ** Why?

35. 35 Reduction of Input Size on the first Sub-operation Φ μ (carrier:invoice) Should we or can we apply the 8.5 below? Φ μ (acc_Num:invoice)[Φ μ (acc_Num:Customer)] Why?

36. 36 acc_Num:invoice and acc_Num:Customer are totally different path Case is: AnB = ┴ Then yes

37. 37 Rule 8.7, 8.9, 8.11 Interesting Helps identify When and where to use selection  to decrease size of input operation to subsequent operation Example Algebra tree slide 28 Selected before join.

38. 38 Addition would be Give computation for finding when rule can be applied automatically in a case and then apply it.

39. 39 AT&T Algebra

40. 40

41. 41 AT&T Algebra Introduction The algebra is derived from the nested relational algebra. AT&T algebra makes heavy use of list comprehensions, a standard notation in the function programming community. AT&T algebra uses the functional programming language Haskell as a notation from presenting the algebra.

42. 42 AT&T data model The data model merges attribute and element nodes, and eliminates comments. Declare Basic Type: Node. Text :: String ->node elem :: Tag -> [Node] ->node ref :: Node ->Node Data on the Web Data on the Web 1999 1999 </bib> elem “bib” [ elem “book”[ elem “@year” [ text “1999” ], elem “title” [text “Data on the web” ] ]]

43. 43 Basic Type Declarations To find the type of a node, isText :: Node -> Bool isElem :: Node -> Bool isRef :: Node -> Bool For a text node, string :: Node -> String For an element node, 1)tag :: Node -> Tag 2)children :: Node -> [Node] For a reference node, dereference :: Node -> Node

44. 44 Nested relational algebra… In the nested relational approach, data is composed of tuples and lists. Tuple values and tuple types are written in round brackets. (1999,"Data on theWeb",["Abiteboul"]) :: (Int,String,[String]) Decompose values: year :: (Int,String,[String]) year (x,y,l) = x

45. 45 Nested relational algebra… Comprehensions: List comprehensions can be used to express fundamental query operations, navigation, cartesian product, nesting, joins. Example: [ value x | x <- children book0, is "author" x ] ==> [ "Abiteboul" ] Normal expression:[ exp | qual1,...,qualn ] bool-exp pat <- list-exp

46. 46 Nested relational algebra… Using comprehensions to write queries. Navigate follow :: Tag -> Node -> [Node] follow t x = [ y | y <- children x, is t y ] Cartesian product [ (value y, value z) | x <- follow "book" bib0, y <- follow "title" x, z <- follow "author" x ] ==> [ ("Data on the Web", "Abiteboul")]

47. 47 Nested relational algebra… Joins. elem "reviews" [ elem "book" [ elem "title" [ text"Data on the Web" ], elem "review" [ text "This is great!" ]] elem “bib” [ elem “book”[ elem “@year” [ text “1999” ], elem “title” [text “Data on the web” ] ]] [ (value y, int (value z), value w) | x <- follow "book" bib0, y <- follow "title" x, z <- follow "@year" x, u <- follow "book" reviews0, v <- follow "title" u, w <- follow “@year" u, y == v ] ==> [("Data on the Web", 1999, "This is great!")]

48. 48 Nested relational algebra… Regular expression matching ( [ (x,y,u) | x <- item "@year", y <- item "title", u <- rep (item "author") ] ) :: Reg (Node,Node,[Node] ) match reg0 book0 ==> [(elem "@year" [text "1999"], elem "title" [text "Data on the Web"], [elem "author" [text "Abiteboul"], elem "author" [text "Buneman"], elem "author" [text "Suciu"] ] ) ] Match :: Reg a -> Node-> [a] Result

49. 49 Nested relational algebra… Sorting. sortBy :: (a -> a -> Bool) -> [a] -> [a] sortBy ( [1,1,2,3] Grouping groupBy :: (a -> a -> Bool) -> [a] -> [[a]] groupBy (==) [3,1,2,1] == [[2],[1,1],[3]]

50. 50 Cross Comparisons of Algebra Niagara and AT&T standalone XML algebras Niagara proposed after W3C had selected proposed standard and has operators which operate on sets of bags At&T algebra chosen as proposed standard by W3C -- expressions resemble high level query language -- latest version of document referred to as “Semantics of XML Query Language XQuery”

51. 51 Future Work Need more different evaluation strategies which would allow for flexible query plans Develop physical operators that take advantage of physical storage structures and generate mapping from query tree to a physical query plan