XML Prague 2012

Focus of this talk

• Status of specifications

• List all significant new features briefly

• Describe the really simple features quickly

• Cover more complex features in depth

• Mike Kay will handle higher order functions

• Mike Kay and I will discuss maps/JSON in a separate presentation

Status: XQuery 3.0, XPath 3.0

• Six documents progressing together

  XQuery 3.0, XPath 3.0, XQueryX 3.0, Data Model 3.0, Functions and Operators 3.0, Serialization 3.0

• Status: Last Call Working Draft

  Comments period ended yesterday (10 Feb 2012)

  Next step: Candidate Recommendation

  Call for Recommendations

Status: XQuery 3.0, XPath 3.0 (2)

• XSLT 3.0, XQuery Update Facility 3.0, XQuery Full Text 3.0 are not yet in Last Call

• Coordination among Working Groups

  Maps/JSON?

  Features needed in development of XSLT 3.0

  New work in XQuery after 3.0

Shared features in XPath 3.0 / XQuery 3.0

• Functions

  Dynamic function calls

  Inline function expressions

  Private functions

• String concatenation operator

  "con" || "cat" || "enate"

• Support for XML Schema 1.1

• Support for union types in function arguments

• Literal URIs in EQNames (like Clark notation)

  Syntax in flux ...

• Specified use of "unknown" types, including types from documents and types from other modules.

• Cleaner separation of Static Base URI (query analysis time), Dynamic Base URI(run time)

XQuery-only Features

• FLWOR Expressions

  group by clause

  tumbling window and sliding window

  count clause

  allowing empty in for clause (outer joins)

• try/catch expressions

• switch expressions

• Computed namespace constructors

• Annotations

  An extensible mechanism for declaring properties of functions or variables

  Examples: %private, %public

• Annotation assertions in function tests

  An extensible mechanism for testing characteristics of functions

• Output declarations to set serialization parameters

FLWOR: group by clause

Input tuple stream

S101, $itemno = P78395)
    ($storeno = S102, $itemno = P94738)
    ($storeno = S101, $itemno = P41653)
    ($storeno = S102, $itemno = P70421)
    ]]>
    

group by clause

Output tuple stream

P78395, P41653))
    ($storeno =  S102, $itemno = (P94738, P70421))
    ]]>
    

Note: value of $storeno changed from current published spec.

Grouping sales by product

$sales is bound to a sequence of sales elements, e.g.:

   S101
   P78395
   125
]]>

$sales is bound to a sequence of products elements, e.g.:

   P78395
   25.00
   Men's Wear
]]>

Query:

]]>

Result:

]]>

Grouping sales by product and category

Query

    {for $s2 in $s1,
         $p in $products[itemno = $s2/itemno]
     let $category := $p/category,
         $revenue := $s2/qty * $p/price
     group by $category
     let $group-revenue := sum($revenue)
     where $group-revenue > 10000
     order by $group-revenue descending
     return 
    }
  ]]>

Result:

   


   
   
]]>

FLWOR: tumbling window and sliding window

• A window identifies a range of items in a binding sequence

  Conditions identify start / end of window

  One tuple per sequence

  Variables in the tuple identify window start, window end, etc.

• Tumbling windows cannot overlap

• Sliding windows can overlap

FLWOR: tumbling window and sliding window - example

Query

Result

4 6 8 10 12

Use cases for tumbling and sliding windows

• Arrange a sequence of items as an HTML table with three columns (using as many rows as necessary).

• Convert sequences of elements to hierarchical structures

  Conditions identify start, end of a section

• Moving averages, exponential smoothing, outliers

• Sequences of events that signal a condition

• Data analytics

FLWOR: count clause

Input tuple stream

($name = "Bob", $age = 21)
($name = "Carol", $age = 19)
($name = "Ted", $age = 20)
($name = "Alice", $age = 22)

count clause

count $counter

Output tuple stream:

($name = "Bob", $age = 21, $counter = 1)
($name = "Carol", $age = 19, $counter = 2)
($name = "Ted", $age = 20, $counter = 3)
($name = "Alice", $age = 22, $counter = 4)

Example: Top N queries

      {$p/name, $p/sales}
   ]]>

FLWOR: allowing empty in for clause

• Used for outer joins

• Binds a variable to () if evaluates to empty sequence

• Query fragment:

  for $x in (100, 200, 300),
      $y allowing empty in ()

• Output tuple stream

  ($x = 100, $y = ()),
  ($x = 200, $y = ()),
  ($x = 300, $y = ())

try / catch expressions

Provides run-time error handling

try {
    $x cast as xs:integer
}
catch err:FORG0001 | err:XPTY0004 {
    0
}

Variables are implicitly bound in catch clause to identify error codes, descriptions, modules, line numbers, etc.

try {
    fn:error(fn:QName('http://www.w3.org/2005/xqt-errors', 'err:FOER0000'))
}
catch * {
    $err:code, $err:value, " module: ",
    $err:module, "(", $err:line-number, ",", $err:column-number, ")"
}

switch expressions

As in most languages you know ...

switch ($animal)
   case "Cow" return "Moo"
   case "Cat" return "Meow"
   case "Duck" return "Quack"
   default return "What's that odd noise?"

Computed namespace constructors

Allow namespace bindings to be created explicitly

Useful for namespaces in content

 {
  namespace xs {"http://www.w3.org/2001/XMLSchema"},
  attribute xsi:type {"xs:integer"},
  23
}]]>

Literal URIs in EQNames

Extends QNames so the entire name can be specified as a literal

BNF

URIQualifiedName 	   ::=    	URILiteral ":" NCName

Example

"http://www.w3.org/2005/xpath-functions/math":pi

Output declarations

Output declarations declare serialization parameters

declare namespace output = "http://www.w3.org/2010/xslt-xquery-serialization";

declare option output:method   "xml";
declare option output:encoding "iso-8859-1";
declare option output:indent   "yes";

Can also put in a file

declare option output:parameter-document "file:///home/me/serialization-parameters.xml";

  
  
  
]]>

Files are the only way to do character maps

    
    
  
]]>