A uniform programming language for implementing XML standards

Transcription

1 A uniform programming language for implementing XML standards Pavel Labath 1, Joachim Niehren 2 1 Commenius University, Bratislava, Slovakia 2 Inria Lille, France Sofsem 2015

2 Motivation Different data transformation languages: XML database querying: XQuery(XPath) Web publishing: XSLT(XPath) transformation composition: XProc(XPath) JSON: web services:???(jsonpath)

3 Motivation Many competing standars, even withing a single technology (XML). (Semi-)formal specifications of existing languages are hunderds of pages long. When developing a new implementation (e.g., streaming), one needs to support many front-ends.

4 Motivation Solution: X-Fun purely functional programming language support for logical path query (*Path) lean formal semantics uniform core language for other (XML) languages

5 Outline Preliminaries X-Fun Compiling other languages to X-Fun Implementation and Experiments

6 Data values, data trees An abstraction over different kinds of trees. parameters Char finite set of characters k N label size data value a word over Char (String = Char ) label a tuple of data values (l = String k ) data tree a tree over l (t ::= l(t 1,..., t n ))

7 Data values, data trees For XML Char all unicode characters k = 4 labels: ("element", v 1, v 2, nil) ("comment", nil, nil, v 3 ) ("document", nil, nil, nil) ("attribute", v 1, v 2, v 3 ) ("processing-instruction", v 1, nil, v 3 ) ("text", v 1, nil, nil)

8 Outline Preliminaries X-Fun Compiling other languages to X-Fun Implementation and Experiments

9 Example <addresses > <address > <name>pavel Labath </name> < com</ > </ address > <address > <name>joachim Niehren </name> </ address >... </ addresses > translate <ol > < l i > <p> Pavel Labath </p> </ l i > < l i > <p> Joachim Niehren </p> </ l i >... </ ol >

10 Example: transformation algorithm f u n c t i o n convert_address ( x ) name = t e x t of the name c h i l d of x output node l i : output node p : output name f o r each c h i l d node x labeled phone : output node p : output t e x t Phone : output the t e x t of x main f u n c t i o n : output node o l : f o r each descendant node x labeled address : c a l l convert_address ( x )

11 Example: transformation in X-Fun fun book : node tree { l e t convert_address = fun x : node tree { l e t name = evalpath [node] ( "$x / c h i l d : : name / t e x t ( ) " ) maketree ( ( " element ", " l i ", n i l, n i l ), maketree ( ( " element ", " p ", n i l, n i l ), map node tree ( subtree, name) ) ) } in in } maketree ( ( " element ", " o l ", n i l, n i l ), map node tree ( convert_ address, evalpath [node] ( "$bookroot / descendant : : address " ) ) )

12 X-Fun features types node, tree, number, bool, char lists: [T ], tuples: T 1... T n functions: T 1 T 2 unions: T 1 T 2 path expressions as values of type path = [char node] computable at runtime "$x/a" syntactic sugar for x :: / :: a :: nil Builtin path expression evaluator evalpath : path [node string] Pattern matching with match expressions.

13 X-Fun Syntax Expressions E ::= x c E 1 :: E 2 (E 1,..., E n ), n 2 Patterns P ::= x : T!(E) P 1 :: P 2 (P 1,..., P n ), n 2 fun x:t 1 T 2 { E } E 1 (E 2 ) match E { P 1 E 1,..., P n E n } try E 1 catch(x) E 2 raise(e)

14 Outline Preliminaries X-Fun Compiling other languages to X-Fun XSLT Implementation and Experiments

15 XSLT: example < x s l : template name= " q " match= " b " mode= "m" > <C> < x s l : c a l l template name= " p " / > </C> </ x s l : template > < x s l : template name= " p " match= " a " mode= "m" > <B> < x s l : apply templates s e l e c t = " * " mode= "m" / > </B> </ x s l : template >

16 XSLT: translation q = fun x : node [ tree ] { maketree ( ( " element ", "C", n i l, n i l ), p ( x ) ) : : n i l } p = fun x : node [ tree ] { maketree ( ( " element ", "B", n i l, n i l ), concat ( map (m, evalpath ( "$x / * " ) ) ) ) : : n i l } m = fun x : node [ tree ] { i f evalpath ( "$x [ s e l f : : a ] " ) n i l then q ( x ) else i f evalpath ( "$x [ s e l f : : b ] " ) n i l then p ( x ) else n i l }

17 XQuery: example f o r $b in / s i t e / open_auctions / open_auction r e t u r n <increase >{ $b / bidder [ 1 ] / increase / t e x t ( ) } </ increase > translate map ( fun b : node tree { maketree ( ( " element ", " increase ", n i l, n i l ), map ( subtree, evalpath ( "$b / bidder [ 1 ] / increase / t e x t ( ) " ) ) ) }, evalpath ( "$x / s i t e / open_auctions / open_auction " ) )

18 XProc A support library of XProc steps implemented in X-Fun E.g., p:wrap-sequence is implemented as: fun ( seq, wrapper ) : node string node { rootnode ( maketree ( ( " element ", wrapper, n i l, n i l " ), map ( subtree, seq ) ) ) }

19 XProc: Example Then translating an XProc pipeline is easy: <p : s p l i t sequence name= " s p l i t " t e s t = " / / b " > <p : i n p u t p o r t = " source " s e l e c t = " / / a " / > </p : s p l i t sequence> <p : wrap sequence wrapper= " sequence " / > translate l e t i n p u t 1 = map ( rootnode, evalpath ( "$source / / a " ) ) in l e t matched, notmatched = s p l i t ( input1, fun x : node bool { evalpath ( "$x / / b " ) n i l } ) in wrap ( matched, " sequence " )

20 Implementation Functional prototype implemented in Java. Using standard java interface for evaluating XPath expressions. XSLT and XQuery compiler support the translation of the entire XMark benchmark (and more)

21 Experiments XQuery and XSLT (comparing against Saxon) On queries without joins our implementation is on par or up to 20% slower. On queries with joins up to 2 times slower. XProc (comparing against XML Calabash) From 2 to 8 times faster on tested inputs. Caveat: Testing not exhaustive due to lack of a testsuite and a XProc X-Fun compiler implementation (evaluated tests were manually translated).

22 Conclusion we have introduced a functional language X-Fun core language for different XML transformation langauges and more efficient implementation with minimal effort Outlook XProc compiler Streaming implementations of X-Fun

23 Thank you